@retiregolden/planner-ui 0.1.0

package/src/planner/sections/AccountsSection.tsx

@@ -0,0 +1,89 @@
+/** Accounts section: add/edit accounts. */
+
+import type { Account } from '@retiregolden/engine/model/plan'
+import { AccountFields } from './AccountFields'
+import { ACCOUNT_LABEL, isIndividuallyOwnedAccount } from './sectionHelpers'
+import { usePlan } from '../planContextCore'
+import { Issues } from './shared'
+import { newId } from './sectionHelpers'
+import { UpdateBalancesPanel } from './UpdateBalancesPanel'
+
+function makeAccount(type: Account['type'], primaryPersonId: string): Account {
+  const base = { id: newId(), ownerPersonId: isIndividuallyOwnedAccount(type) ? primaryPersonId : null, annualReturnPct: null }
+  switch (type) {
+    case 'cash':
+      return { ...base, type, name: 'Savings', balance: 0, annualContribution: 0 }
+    case 'taxable':
+      return {
+        ...base,
+        type,
+        name: 'Brokerage',
+        balance: 0,
+        costBasis: 0,
+        interestYieldPct: 0,
+        dividendYieldPct: 0,
+        qualifiedRatio: 0.85,
+        reinvestDividends: true,
+        annualContribution: 0,
+      }
+    case 'equityComp':
+      return { ...base, type, name: 'RSU / ESPP', balance: 0, costBasis: 0, annualContribution: 0, vestingMode: 'cliff', vestDate: `${new Date().getFullYear()}-12-31` }
+    case 'traditional':
+      return { ...base, type, name: '401(k)', kind: 'employer', balance: 0, annualContribution: 0 }
+    case 'roth':
+      return { ...base, type, name: 'Roth IRA', kind: 'ira', balance: 0, annualContribution: 0 }
+    case 'hsa':
+      return { ...base, type, name: 'HSA', balance: 0, annualContribution: 0 }
+    case 'pension':
+      return { ...base, type, name: 'Pension', source: 'private', startAge: 65, monthlyAmount: 0, colaPct: 0, survivorPct: 50 }
+    case 'annuity':
+      return { ...base, type, name: 'Annuity', startAge: 65, monthlyAmount: 0, colaPct: 0, taxablePct: 100 }
+    case 'property':
+      return { ...base, type, name: 'Home', value: 0, plannedSaleYear: null, expectedNetProceeds: null }
+    case 'debt':
+      return { ...base, type, name: 'Mortgage', balance: 0, interestPct: 5, monthlyPayment: 0 }
+  }
+}
+
+
+export function AccountsSection() {
+  const { plan, update } = usePlan()
+  const primaryPersonId = plan.household.people[0]!.id
+  return (
+    <section>
+      <div className="card">
+        <h2>Accounts</h2>
+        <p className="card-hint">Balances as of today. Investable accounts grow at their expected return (or the default assumption) and are drained per your withdrawal strategy.</p>
+        {plan.accounts.length === 0 ? <div className="empty-state"><p>No accounts yet — add your first below.</p></div> : null}
+        {plan.accounts.map((a, i) => (
+          <div className="item-row" key={a.id} data-testid="account-row" data-account-type={a.type} data-account-name={a.name}>
+            <div className="item-row-head">
+              <span className="item-row-title">
+                <span className="type-chip">{ACCOUNT_LABEL[a.type]}</span>
+                {a.name}
+              </span>
+              <button type="button" className="btn-ghost btn-ghost-danger" onClick={() => update((d) => void d.accounts.splice(i, 1))}>
+                Remove
+              </button>
+            </div>
+            <AccountFields account={a} index={i} />
+          </div>
+        ))}
+        <div className="add-row">
+          {(Object.keys(ACCOUNT_LABEL) as Account['type'][]).map((t) => (
+            <button key={t} type="button" className="btn btn-secondary btn-small" onClick={() => update((d) => void d.accounts.push(makeAccount(t, primaryPersonId)))}>
+              + {ACCOUNT_LABEL[t]}
+            </button>
+          ))}
+        </div>
+        <Issues />
+      </div>
+      <UpdateBalancesPanel />
+    </section>
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Income
+// ---------------------------------------------------------------------------
+

package/src/planner/sections/AllocationPanel.tsx

@@ -0,0 +1,261 @@
+/** Asset-allocation panel and return estimator for allocatable accounts. */
+
+import { useState } from 'react'
+
+import type { AllocationWeights, AssetAllocationPolicy, Plan } from '@retiregolden/engine/model/plan'
+import { ASSET_CLASS_IDS } from '@retiregolden/engine/model/plan'
+import type { AllocatableAccount } from './sectionHelpers'
+import {
+  blendedReturnPct,
+  blendedTaxableYield,
+  DEFAULT_ASSET_CLASS_PARAMS,
+  resolveAssetClassParams,
+  targetWeightsAt,
+} from '@retiregolden/engine/allocation/assetClasses'
+import { NumberField, PercentField, ReadonlyField, SelectField } from '../fields'
+import { Modal } from '../Modal'
+import { currentStartYear } from '../useProjection'
+
+/**
+ * Allocation → expected-return estimator. Long-run nominal assumptions
+ * (illustrative, before fees): stocks ≈ 7%, bonds ≈ 4%, cash ≈ 2.5%.
+ */
+const ASSET_RETURN = { stocks: 7, bonds: 4, cash: 2.5 } as const
+
+function riskLabel(stocksPct: number): string {
+  if (stocksPct < 25) return 'Conservative — low volatility, lower growth'
+  if (stocksPct < 50) return 'Balanced — moderate ups and downs'
+  if (stocksPct < 75) return 'Growth — meaningful swings in bad years'
+  return 'Aggressive — expect large drawdowns on the way'
+}
+
+export function ReturnEstimatorModal({ initialPct, onApply, onClose }: { initialPct: number | null; onApply: (pct: number) => void; onClose: () => void }) {
+  const guessStocks = initialPct === null ? 60 : Math.min(100, Math.max(0, Math.round(((initialPct - ASSET_RETURN.cash) / (ASSET_RETURN.stocks - ASSET_RETURN.cash)) * 100 / 5) * 5))
+  const [stocks, setStocks] = useState(guessStocks)
+  const [bonds, setBonds] = useState(Math.min(100 - guessStocks, 30))
+  const cash = Math.max(0, 100 - stocks - bonds)
+  const blended = (stocks * ASSET_RETURN.stocks + bonds * ASSET_RETURN.bonds + cash * ASSET_RETURN.cash) / 100
+  return (
+    <Modal title="Estimate expected return" onClose={onClose}>
+      <p className="card-hint">
+        Describe roughly how this account is invested; we blend long-run nominal return assumptions (stocks {ASSET_RETURN.stocks}%,
+        bonds {ASSET_RETURN.bonds}%, cash {ASSET_RETURN.cash}% — illustrative, before fees, not a forecast). More stocks
+        means higher expected growth and bigger swings; Monte Carlo is where that risk shows up.
+      </p>
+      <div className="alloc-row">
+        <span>Stocks</span>
+        <input
+          type="range"
+          min={0}
+          max={100}
+          step={5}
+          value={stocks}
+          aria-label="Stocks percent"
+          onChange={(e) => {
+            const v = Number(e.target.value)
+            setStocks(v)
+            setBonds((b) => Math.min(b, 100 - v))
+          }}
+        />
+        <span>{stocks}%</span>
+      </div>
+      <div className="alloc-row">
+        <span>Bonds</span>
+        <input
+          type="range"
+          min={0}
+          max={100 - stocks}
+          step={5}
+          value={bonds}
+          aria-label="Bonds percent"
+          onChange={(e) => setBonds(Number(e.target.value))}
+        />
+        <span>{bonds}%</span>
+      </div>
+      <div className="alloc-row">
+        <span>Cash</span>
+        <span className="muted small">remainder</span>
+        <span>{cash}%</span>
+      </div>
+      <div className="alloc-result">
+        <strong>{blended.toFixed(1)}%</strong>
+        <span className="muted small">{riskLabel(stocks)}</span>
+      </div>
+      <div className="add-row" style={{ marginTop: '1rem' }}>
+        <button type="button" className="btn btn-primary btn-small" onClick={() => { onApply(Math.round(blended * 10) / 10); onClose() }}>
+          Use {blended.toFixed(1)}%
+        </button>
+        <button type="button" className="btn btn-secondary btn-small" onClick={onClose}>
+          Cancel
+        </button>
+      </div>
+    </Modal>
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Asset allocation (opt-in per account)
+// ---------------------------------------------------------------------------
+
+function WeightsGrid({ title, weights, onCommit }: { title?: string; weights: AllocationWeights; onCommit: (w: AllocationWeights) => void }) {
+  const sum = ASSET_CLASS_IDS.reduce((s, id) => s + weights[id], 0)
+  return (
+    <div className="nested-form-section field-span-full">
+      {title ? <h4>{title}</h4> : null}
+      <div className="form-grid nested-control-grid">
+        {ASSET_CLASS_IDS.map((id) => (
+          <PercentField
+            key={id}
+            label={DEFAULT_ASSET_CLASS_PARAMS[id].label}
+            value={weights[id]}
+            min={0}
+            max={100}
+            step={5}
+            onCommit={(v) => onCommit({ ...weights, [id]: Math.min(100, Math.max(0, v ?? 0)) })}
+          />
+        ))}
+      </div>
+      <p className={Math.abs(sum - 100) <= 0.5 ? 'muted small' : 'issue-list small'} role="status">
+        Total {sum.toFixed(0)}%{Math.abs(sum - 100) > 0.5 ? ' — weights must sum to 100%' : ''}
+      </p>
+    </div>
+  )
+}
+
+/**
+ * Allocation policy editor: mode (static / glidepaths), rebalancing, and the
+ * weight grid(s) for the selected mode. All money math (blends, per-year
+ * targets) comes from engine/allocation.
+ */
+export function AllocationPanel({ account, plan, onCommit }: { account: AllocatableAccount; plan: Plan; onCommit: (a: AssetAllocationPolicy) => void }) {
+  const policy = account.allocation!
+  const year = currentStartYear()
+  const params = resolveAssetClassParams(plan.assumptions.assetClassParams)
+  const weightsNow = targetWeightsAt(policy, year)
+  const blendedNow = blendedReturnPct(weightsNow, params)
+  const yieldNow = blendedTaxableYield(weightsNow, params)
+
+  const currentWeights = (): AllocationWeights => {
+    const w = targetWeightsAt(policy, year)
+    return {
+      usStocks: Math.round(w[0]! * 100),
+      intlStocks: Math.round(w[1]! * 100),
+      bonds: Math.round(w[2]! * 100),
+      cash: Math.round(w[3]! * 100),
+    }
+  }
+  const switchMode = (mode: AssetAllocationPolicy['mode']) => {
+    if (mode === policy.mode) return
+    const weights = currentWeights()
+    const shared = { rebalancing: policy.rebalancing }
+    if (mode === 'static') onCommit({ mode, ...shared, weights })
+    else if (mode === 'linear') onCommit({ mode, ...shared, from: weights, to: weights, startYear: year, endYear: year + 20 })
+    else if (mode === 'staged') onCommit({ mode, ...shared, stages: [{ fromYear: year, weights }] })
+    else onCommit({ mode, ...shared, targets: [{ year, weights }] })
+  }
+
+  return (
+    <div className="nested-form-section field-span-full" data-testid="allocation-panel">
+      <div className="form-grid nested-control-grid">
+        <SelectField
+          label="Allocation over time"
+          help="Static holds one target mix. A linear glidepath slides from a starting mix to an ending mix between two years. Staged jumps to a new mix in given years; custom targets interpolate between the mixes you set."
+          value={policy.mode}
+          options={[
+            { value: 'static', label: 'Static target mix' },
+            { value: 'linear', label: 'Linear glidepath (from → to)' },
+            { value: 'staged', label: 'Staged (step changes)' },
+            { value: 'custom', label: 'Custom year targets' },
+          ]}
+          onCommit={switchMode}
+        />
+        <SelectField
+          label="Rebalancing"
+          help="Annual rebalancing trades back to the target mix each January. In a brokerage account those sales realize capital gains through your cost basis; retirement-account rebalancing is tax-free. Drift lets winners run — the mix (and risk) then wanders from the target."
+          value={policy.rebalancing}
+          options={[
+            { value: 'annual', label: 'Rebalance annually to target' },
+            { value: 'none', label: 'No rebalancing (drift)' },
+          ]}
+          onCommit={(v) => onCommit({ ...policy, rebalancing: v })}
+        />
+      </div>
+      {policy.mode === 'static' ? (
+        <WeightsGrid weights={policy.weights} onCommit={(weights) => onCommit({ ...policy, weights })} />
+      ) : null}
+      {policy.mode === 'linear' ? (
+        <>
+          <div className="form-grid nested-control-grid">
+            <NumberField label="From year" value={policy.startYear} min={1900} max={2200} onCommit={(v) => onCommit({ ...policy, startYear: Math.round(v ?? year) })} />
+            <NumberField label="To year" value={policy.endYear} min={1900} max={2200} onCommit={(v) => onCommit({ ...policy, endYear: Math.round(v ?? year + 20) })} />
+          </div>
+          <WeightsGrid title="Starting mix" weights={policy.from} onCommit={(from) => onCommit({ ...policy, from })} />
+          <WeightsGrid title="Ending mix" weights={policy.to} onCommit={(to) => onCommit({ ...policy, to })} />
+        </>
+      ) : null}
+      {policy.mode === 'staged' || policy.mode === 'custom' ? (
+        <>
+          {(policy.mode === 'staged' ? policy.stages : policy.targets).map((row, i) => {
+            const rows = policy.mode === 'staged' ? policy.stages : policy.targets
+            const setRows = (next: typeof rows) =>
+              policy.mode === 'staged'
+                ? onCommit({ ...policy, stages: next as { fromYear: number; weights: AllocationWeights }[] })
+                : onCommit({ ...policy, targets: next as { year: number; weights: AllocationWeights }[] })
+            const rowYear = 'fromYear' in row ? row.fromYear : row.year
+            return (
+              <div key={i} className="nested-phase-row">
+                <div className="form-grid nested-phase-grid">
+                  <NumberField
+                    label={policy.mode === 'staged' ? 'From year' : 'Target year'}
+                    value={rowYear}
+                    min={1900}
+                    max={2200}
+                    onCommit={(v) => {
+                      const y = Math.round(v ?? rowYear)
+                      setRows(rows.map((r, idx) => (idx === i ? ('fromYear' in r ? { ...r, fromYear: y } : { ...r, year: y }) : r)) as typeof rows)
+                    }}
+                  />
+                </div>
+                <WeightsGrid
+                  weights={row.weights}
+                  onCommit={(weights) => setRows(rows.map((r, idx) => (idx === i ? { ...r, weights } : r)) as typeof rows)}
+                />
+                {rows.length > 1 ? (
+                  <button type="button" className="btn btn-secondary btn-small" onClick={() => setRows(rows.filter((_, idx) => idx !== i) as typeof rows)}>
+                    Remove
+                  </button>
+                ) : null}
+              </div>
+            )
+          })}
+          <button
+            type="button"
+            className="btn btn-secondary btn-small"
+            onClick={() => {
+              const weights = currentWeights()
+              if (policy.mode === 'staged') {
+                const lastYear = policy.stages[policy.stages.length - 1]?.fromYear ?? year
+                onCommit({ ...policy, stages: [...policy.stages, { fromYear: lastYear + 5, weights }] })
+              } else {
+                const lastYear = policy.targets[policy.targets.length - 1]?.year ?? year
+                onCommit({ ...policy, targets: [...policy.targets, { year: lastYear + 5, weights }] })
+              }
+            }}
+          >
+            + Add {policy.mode === 'staged' ? 'stage' : 'target'}
+          </button>
+        </>
+      ) : null}
+      <ReadonlyField
+        label="This year's blend"
+        help="Expected nominal return of this account's target mix this year, blended from the asset-class assumptions. For a brokerage account, the mix also sets the taxable interest/dividend yield used for annual tax drag."
+        value={
+          account.type === 'taxable'
+            ? `${blendedNow.toFixed(1)}% return · ${yieldNow.interestYieldPct.toFixed(1)}% interest + ${yieldNow.dividendYieldPct.toFixed(1)}% dividends`
+            : `${blendedNow.toFixed(1)}% return`
+        }
+      />
+    </div>
+  )
+}
+

package/src/planner/sections/AssumptionsSection.tsx

@@ -0,0 +1,256 @@
+/** Assumptions section: inflation, returns, taxes, asset classes. */
+
+import { Link } from 'react-router-dom'
+
+import type { AssetClassId } from '@retiregolden/engine/model/plan'
+import { ASSET_CLASS_IDS } from '@retiregolden/engine/model/plan'
+import { DEFAULT_ASSET_CLASS_PARAMS, resolveAssetClassParams } from '@retiregolden/engine/allocation/assetClasses'
+import { LATEST_PACK_YEAR, TRUSTEES_DEFAULT_SS_HAIRCUT } from '@retiregolden/engine/params'
+import { usePlan } from '../planContextCore'
+import { provenanceSource } from '../provenanceLinks'
+import { CheckboxField, MoneyField, NumberField, PercentField, SelectField } from '../fields'
+import { LearnAboutScreen } from '../../learn/LearnAboutScreen'
+import { LEARN } from '../learnLinks'
+import { Issues } from './shared'
+
+/**
+ * Assumptions-level asset-class table: return / volatility / yield per class,
+ * shown with the sourced defaults and editable as overrides. Only accounts
+ * that opt into "Model asset classes" use these numbers.
+ */
+function AssetClassAssumptions() {
+  const { plan, update } = usePlan()
+  const resolved = resolveAssetClassParams(plan.assumptions.assetClassParams)
+  const hasOverrides = plan.assumptions.assetClassParams !== undefined
+  type OverrideKey = 'returnPct' | 'volatilityPct' | 'interestYieldPct' | 'dividendYieldPct' | 'qualifiedRatioPct'
+  const setParam = (id: AssetClassId, key: OverrideKey, v: number) =>
+    update((d) => {
+      const overrides = d.assumptions.assetClassParams ?? {}
+      overrides[id] = { ...overrides[id], [key]: v }
+      d.assumptions.assetClassParams = overrides
+    })
+  return (
+    <>
+      <h3>Asset classes</h3>
+      <p className="card-hint">
+        Used by accounts with "Model asset classes" turned on: growth blends these returns, Monte Carlo shocks each
+        class with long-horizon historical volatility and correlations, and brokerage yields drive annual tax drag.
+        Defaults are documented planning assumptions — edit them to match your own outlook.
+        {hasOverrides ? (
+          <>
+            {' '}
+            <button
+              type="button"
+              className="btn-ghost"
+              onClick={() => update((d) => void (d.assumptions.assetClassParams = undefined))}
+            >
+              Reset to defaults
+            </button>
+          </>
+        ) : null}
+      </p>
+      {ASSET_CLASS_IDS.map((id) => {
+        const p = resolved[id]
+        const stockLike = id === 'usStocks' || id === 'intlStocks'
+        return (
+          <div key={id} className="nested-form-section" data-testid={`asset-class-${id}`}>
+            <h4>{p.label}</h4>
+            <div className="form-grid nested-control-grid">
+              <PercentField label="Expected return" value={p.returnPct} onCommit={(v) => setParam(id, 'returnPct', v ?? DEFAULT_ASSET_CLASS_PARAMS[id].returnPct)} />
+              <PercentField label="Volatility" help="Annual standard deviation of returns; drives the size of this class's Monte Carlo shocks." value={p.volatilityPct} min={0} onCommit={(v) => setParam(id, 'volatilityPct', v ?? DEFAULT_ASSET_CLASS_PARAMS[id].volatilityPct)} />
+              {stockLike ? (
+                <>
+                  <PercentField label="Dividend yield" help="Distributed as dividends each year; taxable in a brokerage account." value={p.dividendYieldPct} min={0} onCommit={(v) => setParam(id, 'dividendYieldPct', v ?? DEFAULT_ASSET_CLASS_PARAMS[id].dividendYieldPct)} />
+                  <PercentField label="Qualified share" help="Share of this class's dividends taxed at long-term capital-gain rates." value={p.qualifiedRatioPct} min={0} max={100} onCommit={(v) => setParam(id, 'qualifiedRatioPct', v ?? DEFAULT_ASSET_CLASS_PARAMS[id].qualifiedRatioPct)} />
+                </>
+              ) : (
+                <PercentField label="Interest yield" help="Distributed as taxable interest each year in a brokerage account." value={p.interestYieldPct} min={0} onCommit={(v) => setParam(id, 'interestYieldPct', v ?? DEFAULT_ASSET_CLASS_PARAMS[id].interestYieldPct)} />
+              )}
+            </div>
+          </div>
+        )
+      })}
+    </>
+  )
+}
+
+export function AssumptionsSection() {
+  const { plan, update } = usePlan()
+  const a = plan.assumptions
+  return (
+    <section>
+      <div className="card">
+        <h2>Assumptions</h2>
+        <p className="card-hint">Sensible defaults; every projection is only as good as these. Monte Carlo varies returns and inflation around them.</p>
+        <div className="form-grid">
+          <PercentField
+            label="Inflation"
+            help="How fast prices rise each year. Results are shown in today's dollars, so this sets how much future dollars are discounted back."
+            learn={LEARN.generalInflation}
+            value={a.inflationPct}
+            onCommit={(v) => update((d) => void (d.assumptions.inflationPct = v ?? 2.5))}
+          />
+          <PercentField
+            label="Healthcare extra inflation"
+            hint="On top of general inflation."
+            help="Additional inflation applied to healthcare and Medicare costs."
+            learn={LEARN.healthcareInflation}
+            value={a.healthcareExtraInflationPct}
+            onCommit={(v) => update((d) => void (d.assumptions.healthcareExtraInflationPct = v ?? 3))}
+          />
+          <PercentField
+            label="Default return"
+            hint="For accounts without their own."
+            help="Assumed long-term nominal return rate for investment accounts."
+            learn={LEARN.investmentReturns}
+            value={a.defaultReturnPct}
+            onCommit={(v) => update((d) => void (d.assumptions.defaultReturnPct = v ?? 5.5))}
+          />
+          <PercentField
+            label="State effective tax (override)"
+            help="Leave at 0 to use the modeled per-state brackets for your state(s) of residence. Set a flat rate above 0 to override the model everywhere — useful to correct a state, or to approximate a state that isn't modeled yet."
+            hint="0 = use modeled state brackets."
+            learn={LEARN.stateTaxOverride}
+            source={provenanceSource('state-income-tax')}
+            value={a.stateEffectiveTaxPct}
+            min={0}
+            max={20}
+            onCommit={(v) => update((d) => void (d.assumptions.stateEffectiveTaxPct = v ?? 0))}
+          />
+          <PercentField
+            label="Local income tax"
+            help="Optional flat city/county income tax. When modeled state brackets are active, this applies to state taxable income; with the state override, it adds to the same flat override base."
+            hint="For MD counties, NYC, OH municipalities."
+            value={a.localIncomeTaxPct}
+            min={0}
+            max={10}
+            onCommit={(v) => update((d) => void (d.assumptions.localIncomeTaxPct = v ?? 0))}
+          />
+          <MoneyField
+            label="Recent annual MAGI"
+            hint="Seeds IRMAA's two-year lookback."
+            help="Used to seed the two-year lookback for Medicare premium calculations during your first two years."
+            learn={LEARN.recentMagi}
+            source={provenanceSource('medicare-irmaa')}
+            value={a.recentAnnualMagi}
+            onCommit={(v) => update((d) => void (d.assumptions.recentAnnualMagi = v ?? 0))}
+          />
+          <PercentField
+            label="Safe withdrawal rate (SWR)"
+            help="The percentage of your portfolio you assume is safe to withdraw in the first year of retirement, adjusted for inflation thereafter. For example, 4% is the common rule-of-thumb lens."
+            learn={LEARN.fiNumber}
+            value={a.safeWithdrawalRatePct ?? 4}
+            min={0.1}
+            onCommit={(v) => update((d) => void (d.assumptions.safeWithdrawalRatePct = v ?? 4))}
+          />
+          <SelectField
+            label="Social Security COLA"
+            help="How the annual cost-of-living adjustment is modeled: matched to general inflation, or set at a fixed rate."
+            learn={LEARN.ssCola}
+            value={a.ssCola.mode}
+            options={[
+              { value: 'matchInflation', label: 'Match inflation' },
+              { value: 'fixed', label: 'Fixed rate' },
+            ]}
+            onCommit={(v) =>
+              update((d) => {
+                d.assumptions.ssCola = v === 'fixed' ? { mode: 'fixed', annualPct: 2 } : { mode: 'matchInflation' }
+              })
+            }
+          />
+          {a.ssCola.mode === 'fixed' ? (
+            <PercentField
+              label="COLA rate"
+              help="The annual cost-of-living adjustment rate."
+              learn={LEARN.ssCola}
+              value={a.ssCola.annualPct}
+              onCommit={(v) => update((d) => void (d.assumptions.ssCola = { mode: 'fixed', annualPct: v ?? 2 }))}
+            />
+          ) : null}
+          <PercentField
+            label="Heir tax rate"
+            help="Assumed tax rate heirs pay on inherited traditional pre-tax balances, used for the after-tax estate metric."
+            learn={LEARN.heirTaxRate}
+            value={a.heirTaxRatePct}
+            min={0}
+            max={50}
+            onCommit={(v) => update((d) => void (d.assumptions.heirTaxRatePct = v ?? 25))}
+          />
+          <CheckboxField
+            label="Override heir tax by account class"
+            help="Set different heir tax rates for traditional and HSA accounts instead of applying the flat rate to all pre-tax balances. For example, a higher-income heir might face a 32% marginal rate on inherited traditional IRA distributions but only 22% on a modest HSA."
+            value={a.heirTaxByClass !== undefined}
+            onCommit={(v) =>
+              update((d) => void (d.assumptions.heirTaxByClass = v ? { traditional: d.assumptions.heirTaxRatePct, hsa: d.assumptions.heirTaxRatePct } : undefined))
+            }
+          />
+          {a.heirTaxByClass !== undefined ? (
+            <>
+              <PercentField
+                label="Traditional heir tax"
+                help="Tax rate heirs pay on inherited traditional IRA/401(k) balances. Overrides the flat heir tax rate for this account class."
+                value={a.heirTaxByClass.traditional ?? a.heirTaxRatePct}
+                min={0}
+                max={50}
+                onCommit={(v) =>
+                  update((d) => {
+                    if (!d.assumptions.heirTaxByClass) return
+                    d.assumptions.heirTaxByClass.traditional = v ?? undefined
+                  })
+                }
+              />
+              <PercentField
+                label="HSA heir tax"
+                help="Tax rate heirs pay on inherited HSA balances (non-spouse beneficiary). Overrides the flat heir tax rate for this account class."
+                value={a.heirTaxByClass.hsa ?? a.heirTaxRatePct}
+                min={0}
+                max={50}
+                onCommit={(v) =>
+                  update((d) => {
+                    if (!d.assumptions.heirTaxByClass) return
+                    d.assumptions.heirTaxByClass.hsa = v ?? undefined
+                  })
+                }
+              />
+            </>
+          ) : null}
+        </div>
+
+        <AssetClassAssumptions />
+
+        <h3>Social Security trust fund</h3>
+        <div className="form-grid">
+          <CheckboxField
+            label="Model a benefit cut"
+            hint="Trustees project depletion around 2034 absent action."
+            help="Model a benefit cut if the Social Security trust fund exhausts reserves."
+            learn={LEARN.ssTrustFund}
+            source={provenanceSource('social-security')}
+            value={a.ssHaircut !== null}
+            onCommit={(v) => update((d) => void (d.assumptions.ssHaircut = v ? { ...TRUSTEES_DEFAULT_SS_HAIRCUT } : null))}
+          />
+          {a.ssHaircut ? (
+            <>
+              <NumberField label="From year" value={a.ssHaircut.fromYear} min={1900} max={2200} onCommit={(v) => update((d) => void (d.assumptions.ssHaircut!.fromYear = Math.round(v ?? TRUSTEES_DEFAULT_SS_HAIRCUT.fromYear)))} />
+              <PercentField label="Cut" value={a.ssHaircut.cutPct} min={0} max={100} onCommit={(v) => update((d) => void (d.assumptions.ssHaircut!.cutPct = v ?? TRUSTEES_DEFAULT_SS_HAIRCUT.cutPct))} />
+            </>
+          ) : null}
+        </div>
+
+        <p className="card-hint">
+          Tax brackets, contribution limits, RMD factors, Medicare/IRMAA, and per-state rules come from published{' '}
+          {LATEST_PACK_YEAR} figures. <Link to="/disclaimer">See where the numbers come from →</Link>{' '}
+          <Link to={`/plan/${plan.id}/assumptions-card`}>See every live assumption on one card →</Link>
+        </p>
+        <Issues />
+
+        <LearnAboutScreen route="/plan/:planId/assumptions" limit={10} />
+      </div>
+    </section>
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Insurance (roadmap V6)
+// ---------------------------------------------------------------------------
+