@retiregolden/planner-ui 0.1.0

package/src/planner/insights/InsightCardView.tsx

@@ -0,0 +1,340 @@
+import { useState } from 'react'
+import { Link, useNavigate } from 'react-router-dom'
+import type { Plan } from '@retiregolden/engine/model/plan'
+import { usePlan } from '../planContextCore'
+import { useProjection, taxCalculatorFor, seedFromPlanId } from '../useProjection'
+import { packForYear } from '@retiregolden/engine/params'
+import { applyScenarioPatch } from '@retiregolden/engine/scenarios/scenarios'
+import { createDecisionContext, evaluateInsightAction } from '@retiregolden/engine/decisions'
+import { runMonteCarlo } from '../../mc/pool'
+import { registry } from '@retiregolden/engine/insights/registry'
+import type { InsightAction, InsightCard, InsightImpact } from '@retiregolden/engine/insights/types'
+import { LearnLink } from '../../learn/LearnLink'
+import { fmtMoney, fmtMoneyCompact } from '../format'
+
+function makeScenarioId(): string {
+  return typeof crypto !== 'undefined' && 'randomUUID' in crypto
+    ? `scenario-${crypto.randomUUID()}`
+    : `scenario-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+}
+
+function uniqueScenarioName(baseName: string, plan: Plan): string {
+  const names = new Set(plan.scenarios.map((scenario) => scenario.name))
+  if (!names.has(baseName)) return baseName
+
+  let suffix = 2
+  while (names.has(`${baseName} (${suffix})`)) {
+    suffix += 1
+  }
+  return `${baseName} (${suffix})`
+}
+
+export function InsightCardView({ card, onDismiss }: { card: InsightCard; onDismiss: () => void }) {
+  const { plan, update } = usePlan()
+  const projectionView = useProjection(plan)
+  const navigate = useNavigate()
+
+  const [expanded, setExpanded] = useState(false)
+  const [exactImpact, setExactImpact] = useState<InsightImpact | null>(null)
+  // Detectors may refine their action during evaluate() (e.g. the spending
+  // headroom card solves the exact level); Add-as-scenario must use that one.
+  const [exactAction, setExactAction] = useState<InsightAction | null>(null)
+  const [mcDelta, setMcDelta] = useState<number | null>(null)
+  const [loadingExact, setLoadingExact] = useState(false)
+  const [loadingMc, setLoadingMc] = useState(false)
+  const [previewError, setPreviewError] = useState<string | null>(null)
+  const [undoPlan, setUndoPlan] = useState<Plan | null>(null)
+
+  const handleToggleExpand = async () => {
+    const nextExpanded = !expanded
+    setExpanded(nextExpanded)
+    setPreviewError(null)
+
+    if (nextExpanded && card.action.kind === 'preview-scenario' && !exactImpact && !loadingExact) {
+      setLoadingExact(true)
+      try {
+        const detector = registry.find((d) => d.id === card.id)
+        if (!detector || !detector.evaluate) {
+          setPreviewError('This insight cannot be previewed yet.')
+          return
+        }
+
+        const paramsLookup = packForYear(projectionView.startYear)
+        const ctx = {
+          plan,
+          projection: {
+            result: projectionView.result,
+            summary: projectionView.summary,
+            startYear: projectionView.startYear,
+            deflate: projectionView.deflate,
+          },
+          params: paramsLookup.pack,
+        }
+
+        const evalResult = detector.evaluate(ctx)
+        if (evalResult.action.kind === 'preview-scenario') {
+          const patch = evalResult.action.patch
+          const applied = applyScenarioPatch(plan, patch)
+          if (applied.ok) {
+            // Shared exact-ledger evaluator (decision engine): the same core
+            // the Roth & Tax Optimizer tournament uses, so this card's exact
+            // deltas and recommendation state match that surface. Baseline is
+            // reused from the memoized projection — one extra simulate() only.
+            const decisionCtx = createDecisionContext(
+              plan,
+              { startYear: projectionView.startYear, taxCalculator: taxCalculatorFor(plan) },
+              { result: projectionView.result, summary: projectionView.summary },
+              // Per-candidate tax stacks: a preview patch may change tax
+              // assumptions (e.g. relocation clearing the flat override).
+              taxCalculatorFor,
+            )
+            const { evaluation, impact } = evaluateInsightAction(decisionCtx, card, evalResult.action)
+            if (evaluation.recommendationState === 'diagnostic') {
+              setPreviewError(evaluation.diagnostics.join(' ') || 'This insight could not be compared against the base plan.')
+            } else {
+              // Keep the detector's own evaluated summary line (e.g. the solved
+              // spending level) alongside the shared evaluator's exact deltas.
+              setExactImpact(
+                evalResult.impact?.qualitative ? { ...impact, qualitative: evalResult.impact.qualitative } : impact,
+              )
+              setExactAction(evalResult.action)
+
+              // If it impacts Monte Carlo success rate, run async MC pool query
+              if (card.impact.successRateDeltaPct !== undefined) {
+                setLoadingMc(true)
+                const seed = seedFromPlanId(plan.id)
+                const model = { type: 'historical' as const, mode: 'iid' as const, equityWeightPct: 60 }
+                const mcOpts = {
+                  startYear: projectionView.startYear,
+                  pathCount: 250, // fast preview size
+                  seed,
+                  model,
+                }
+                const [baseMc, patchMc] = await Promise.all([
+                  runMonteCarlo(plan, mcOpts),
+                  runMonteCarlo(applied.plan, mcOpts),
+                ])
+                setMcDelta((patchMc.successRate - baseMc.successRate) * 100)
+                setLoadingMc(false)
+              }
+            }
+          } else {
+            setPreviewError(`This suggestion can't be applied to your plan: ${applied.issues.join('; ')}`)
+          }
+        }
+      } catch (err) {
+        setPreviewError(err instanceof Error ? err.message : 'Failed to evaluate this insight.')
+        setLoadingMc(false)
+      } finally {
+        setLoadingExact(false)
+      }
+    }
+  }
+
+  const handleAddScenario = () => {
+    const action = exactAction?.kind === 'preview-scenario' ? exactAction : card.action
+    if (action.kind !== 'preview-scenario') return
+    const applied = applyScenarioPatch(plan, action.patch)
+    if (!applied.ok) {
+      setPreviewError(`This suggestion can't be applied to your plan: ${applied.issues.join('; ')}`)
+      return
+    }
+    const name = uniqueScenarioName(action.scenarioName, plan)
+    update((d) => {
+      d.scenarios.push({
+        id: makeScenarioId(),
+        name,
+        patch: action.patch,
+      })
+    })
+    navigate(`/plan/${plan.id}/scenarios`)
+  }
+
+  const handleApplyToggle = () => {
+    if (card.action.kind !== 'apply-toggle') return
+    const applied = applyScenarioPatch(plan, card.action.patch)
+    if (!applied.ok) {
+      setPreviewError(`This change can't be applied to your plan: ${applied.issues.join('; ')}`)
+      return
+    }
+    setUndoPlan(plan)
+    update((d) => {
+      Object.assign(d, applied.plan)
+    })
+  }
+
+  const handleUndoToggle = () => {
+    if (!undoPlan) return
+    const previous = undoPlan
+    setUndoPlan(null)
+    update((d) => {
+      Object.assign(d, previous)
+    })
+  }
+
+  // Formatting helpers
+  const formatDelta = (val: number, isGoodPositive = true) => {
+    if (val === 0) return 'no change'
+    const sign = val > 0 ? '+' : ''
+    const good = (val > 0 && isGoodPositive) || (val < 0 && !isGoodPositive)
+    return (
+      <span className={good ? 'delta-pos' : 'delta-neg'}>
+        {sign}
+        {fmtMoney(val)}
+      </span>
+    )
+  }
+
+  const confidenceChips = {
+    high: { className: 'type-chip type-chip--good', label: 'High Confidence' },
+    medium: { className: 'type-chip type-chip--warn', label: 'Medium Confidence' },
+    low: { className: 'type-chip type-chip--muted', label: 'Low Confidence' },
+  }
+  const confidence = confidenceChips[card.confidence]
+
+  return (
+    <div className="card insight-card">
+      <button
+        type="button"
+        className="btn-ghost insight-dismiss"
+        onClick={onDismiss}
+        aria-label="Dismiss this recommendation"
+        title="Dismiss this recommendation"
+      >
+        <svg
+          viewBox="0 0 24 24"
+          width="16"
+          height="16"
+          fill="none"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          aria-hidden="true"
+        >
+          <line x1="6" y1="6" x2="18" y2="18" />
+          <line x1="18" y1="6" x2="6" y2="18" />
+        </svg>
+      </button>
+
+      {/* Cards always render under their category's group heading, so the
+          category chip would just repeat it — only the confidence chip earns
+          its place. */}
+      <div className="insight-badges">
+        <span className={confidence.className}>{confidence.label}</span>
+      </div>
+
+      <h3 className="insight-card-title">{card.title}</h3>
+      <p className="insight-rationale">{card.rationale}</p>
+
+      {/* Impact Section */}
+      <div className="insight-impact-box">
+        {expanded && exactImpact ? (
+          <div>
+            {exactImpact.qualitative ? <p>{exactImpact.qualitative}</p> : null}
+            <div className="insight-impact-grid">
+              {exactImpact.endingAfterTaxEstateDelta !== undefined && (
+                <div>
+                  <span className="muted">Ending estate delta:</span>{' '}
+                  {formatDelta(exactImpact.endingAfterTaxEstateDelta, true)}
+                </div>
+              )}
+              {exactImpact.lifetimeTaxDelta !== undefined && (
+                <div>
+                  <span className="muted">Lifetime tax delta:</span>{' '}
+                  {formatDelta(exactImpact.lifetimeTaxDelta, false)}
+                </div>
+              )}
+              {card.impact.successRateDeltaPct !== undefined && (
+                <div>
+                  <span className="muted">Monte Carlo success:</span>{' '}
+                  {loadingMc ? (
+                    <span className="muted">calculating…</span>
+                  ) : mcDelta !== null ? (
+                    <span className={mcDelta >= 0 ? 'delta-pos' : 'delta-neg'}>
+                      {mcDelta > 0 ? '+' : ''}
+                      {mcDelta.toFixed(1)}%
+                    </span>
+                  ) : (
+                    '--'
+                  )}
+                </div>
+              )}
+            </div>
+            <div className="insight-impact-note">
+              * Calculated by running a full plan re-simulation side-by-side.
+            </div>
+          </div>
+        ) : (
+          <div>
+            <strong>Estimated impact:</strong>{' '}
+            {card.impact.qualitative ? (
+              <span>{card.impact.qualitative}</span>
+            ) : (
+              <span>
+                {card.impact.endingAfterTaxEstateDelta !== undefined && (
+                  <span>≈ {fmtMoneyCompact(card.impact.endingAfterTaxEstateDelta)} estate delta </span>
+                )}
+                {card.impact.lifetimeTaxDelta !== undefined && (
+                  <span>≈ {fmtMoneyCompact(card.impact.lifetimeTaxDelta)} tax savings </span>
+                )}
+              </span>
+            )}
+          </div>
+        )}
+      </div>
+
+      {previewError && (
+        <div className="callout callout--warn insight-error" role="alert">
+          {previewError}
+        </div>
+      )}
+
+      {/* Actions Row */}
+      <div className="insight-actions">
+        <div className="insight-actions-links">
+          {card.learnSlug && <LearnLink slug={card.learnSlug} label="Learn more" />}
+          {card.plannerRoute && (
+            <Link to={`/plan/${plan.id}/${card.plannerRoute}`} className="learn-link">
+              Go to screen
+            </Link>
+          )}
+        </div>
+
+        <div className="insight-actions-buttons">
+          {card.action.kind === 'preview-scenario' && (
+            <>
+              <button
+                type="button"
+                className="btn btn-secondary btn-small"
+                onClick={handleToggleExpand}
+                disabled={loadingExact}
+              >
+                {loadingExact ? 'Loading…' : expanded ? 'Hide preview' : 'Preview impact'}
+              </button>
+              {expanded && exactImpact && (
+                <button type="button" className="btn btn-primary btn-small" onClick={handleAddScenario}>
+                  Add as scenario
+                </button>
+              )}
+            </>
+          )}
+          {card.action.kind === 'advisory' && (
+            <span className="insight-advisory-note">Advisory only</span>
+          )}
+          {card.action.kind === 'apply-toggle' && (
+            <>
+              <button type="button" className="btn btn-primary btn-small" onClick={handleApplyToggle}>
+                Apply to plan
+              </button>
+              {undoPlan && (
+                <button type="button" className="btn btn-secondary btn-small" onClick={handleUndoToggle}>
+                  Undo
+                </button>
+              )}
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}

package/src/planner/insights/InsightsPage.tsx

@@ -0,0 +1,204 @@
+import { useState, useMemo } from 'react'
+import { Link } from 'react-router-dom'
+import { usePlan } from '../planContextCore'
+import { useProjection } from '../useProjection'
+import { packForYear } from '@retiregolden/engine/params'
+import { runScreen } from '@retiregolden/engine/insights/runInsights'
+import type { InsightCard, InsightCategory } from '@retiregolden/engine/insights/types'
+import { readLocal, STORAGE_KEYS, writeLocal } from '../../data/localStore'
+import { CATEGORY_LABELS } from './categoryLabels'
+import { InsightCardView } from './InsightCardView'
+import { LiveStatus } from '../LiveStatus'
+
+function insightRenderKey(card: InsightCard): string {
+  return `${card.id}:${card.rationale}:${JSON.stringify(card.action)}`
+}
+
+export function InsightsPage() {
+  const { plan } = usePlan()
+  const projectionView = useProjection(plan)
+
+  // Manage dismissed cards state loaded from localStorage
+  const [dismissedMap, setDismissedMap] = useState<Record<string, string[]>>(() => {
+    try {
+      const stored = readLocal(STORAGE_KEYS.insightsDismissed)
+      return stored ? JSON.parse(stored) : {}
+    } catch {
+      return {}
+    }
+  })
+
+  // State for collapsible category groups (default expanded: true)
+  const [collapsedCategories, setCollapsedCategories] = useState<Record<string, boolean>>({})
+
+  // Screen-reader announcement for dismiss/restore (visual change is otherwise silent).
+  const [liveMessage, setLiveMessage] = useState('')
+
+  // Save dismissed cards to localStorage
+  const dismissCard = (cardId: string) => {
+    const nextMap = {
+      ...dismissedMap,
+      [plan.id]: [...(dismissedMap[plan.id] ?? []), cardId],
+    }
+    setDismissedMap(nextMap)
+    writeLocal(STORAGE_KEYS.insightsDismissed, JSON.stringify(nextMap))
+    setLiveMessage(`Insight dismissed. ${nextMap[plan.id]!.length} dismissed on this plan.`)
+  }
+
+  // Restore all dismissed cards for this plan
+  const restoreDismissed = () => {
+    const restoredCount = dismissedMap[plan.id]?.length ?? 0
+    const nextMap = { ...dismissedMap }
+    delete nextMap[plan.id]
+    setDismissedMap(nextMap)
+    writeLocal(STORAGE_KEYS.insightsDismissed, JSON.stringify(nextMap))
+    setLiveMessage(
+      `Restored ${restoredCount} dismissed insight${restoredCount === 1 ? '' : 's'}.`,
+    )
+  }
+
+  // Run detectors synchronously
+  const allCards = useMemo(() => {
+    const paramsLookup = packForYear(projectionView.startYear)
+    const ctx = {
+      plan,
+      projection: {
+        result: projectionView.result,
+        summary: projectionView.summary,
+        startYear: projectionView.startYear,
+        deflate: projectionView.deflate,
+      },
+      params: paramsLookup.pack,
+    }
+    return runScreen(ctx)
+  }, [plan, projectionView])
+
+  // Filter out dismissed cards
+  const planDismissed = useMemo(() => dismissedMap[plan.id] ?? [], [dismissedMap, plan.id])
+  const visibleCards = useMemo(() => {
+    return allCards.filter((card) => !planDismissed.includes(card.id))
+  }, [allCards, planDismissed])
+
+  // Group visible cards by category
+  const groupedCards = useMemo(() => {
+    const groups: Partial<Record<InsightCategory, InsightCard[]>> = {}
+    for (const card of visibleCards) {
+      if (!groups[card.category]) {
+        groups[card.category] = []
+      }
+      groups[card.category]!.push(card)
+    }
+    return groups
+  }, [visibleCards])
+
+  const toggleCategory = (cat: InsightCategory) => {
+    setCollapsedCategories((prev) => ({
+      ...prev,
+      [cat]: !prev[cat],
+    }))
+  }
+
+  return (
+    <section>
+      <LiveStatus message={liveMessage} />
+      <div className="card">
+        <h2>Insights & Recommendations</h2>
+        <p className="card-hint">
+          RetireGolden scans your plan to identify personalized planning opportunities. These recommendations update live as you edit.
+        </p>
+        <div className="callout callout--info">
+          <strong>Educational only.</strong> These suggestions are for educational purposes based on the rules and assumptions modeled. They do not constitute financial, tax, or legal advice.
+        </div>
+      </div>
+
+      <div className="insight-optimizer-row">
+        <div className="card">
+          <h2>Roth & Tax Optimizer</h2>
+          <p className="card-hint">
+            Compare candidate Roth-conversion schedules on your full year-by-year projection and see the best result found for your plan.
+          </p>
+          <Link to={`/plan/${plan.id}/optimize`} className="btn btn-primary btn-small">
+            Run optimizer →
+          </Link>
+        </div>
+
+        {plan.incomes.some((i) => i.type === 'socialSecurity') && (
+          <div className="card">
+            <h2>Social Security Optimizer</h2>
+            <p className="card-hint">
+              Analyze every claiming age combination side-by-side to find the schedule that maximizes your ending estate.
+            </p>
+            <Link to={`/plan/${plan.id}/social-security-analysis`} className="btn btn-secondary btn-small">
+              Run SS sweep →
+            </Link>
+          </div>
+        )}
+      </div>
+
+      {visibleCards.length === 0 ? (
+        <div className="card empty-state">
+          <h2>No opportunities found right now</h2>
+          <p className="muted insight-empty-note">
+            Your plan already covers the big levers or no new opportunities were detected. Try adjusting your strategy or assumptions.
+          </p>
+          {planDismissed.length > 0 && (
+            <button type="button" className="btn btn-secondary btn-small" onClick={restoreDismissed}>
+              Restore dismissed insights
+            </button>
+          )}
+        </div>
+      ) : (
+        <div>
+          {Object.entries(groupedCards).map(([cat, cards]) => {
+            const category = cat as InsightCategory
+            const isCollapsed = collapsedCategories[category] ?? false
+            return (
+              <div key={category} className="insight-category-group">
+                <h2 className="insight-category-heading">
+                  <button
+                    type="button"
+                    className="insight-category-header"
+                    aria-expanded={!isCollapsed}
+                    onClick={() => toggleCategory(category)}
+                  >
+                    <span>
+                      {CATEGORY_LABELS[category]} ({cards!.length})
+                    </span>
+                    <svg
+                    viewBox="0 0 24 24"
+                    width="16"
+                    height="16"
+                    fill="none"
+                    stroke="currentColor"
+                    strokeWidth="2"
+                    strokeLinecap="round"
+                    strokeLinejoin="round"
+                    aria-hidden="true"
+                  >
+                    <polyline points={isCollapsed ? '6 9 12 15 18 9' : '6 15 12 9 18 15'} />
+                    </svg>
+                  </button>
+                </h2>
+                {!isCollapsed && (
+                  <div className="insight-cards-list">
+                    {cards!.map((card) => (
+                      <InsightCardView key={insightRenderKey(card)} card={card} onDismiss={() => dismissCard(card.id)} />
+                    ))}
+                  </div>
+                )}
+              </div>
+            )
+          })}
+
+          {planDismissed.length > 0 && (
+            <div className="insight-restore-row">
+              <button type="button" className="btn btn-secondary btn-small" onClick={restoreDismissed}>
+                Restore dismissed insights ({planDismissed.length})
+              </button>
+            </div>
+          )}
+        </div>
+      )}
+    </section>
+  )
+}

package/src/planner/insights/categoryLabels.ts

@@ -0,0 +1,11 @@
+import type { InsightCategory } from '@retiregolden/engine/insights/types'
+
+/** Human-readable names for insight categories, shared by the page grouping and card badges. */
+export const CATEGORY_LABELS: Record<InsightCategory, string> = {
+  'tax-brackets': 'Tax Brackets & Headroom',
+  'accounts-contributions': 'Account Contributions',
+  'withdrawals-charitable': 'Withdrawals & Charitable Giving',
+  'sequence-risk': 'Sequence Risk & Spending',
+  'social-security': 'Social Security & Spousal',
+  'longevity-insurance-geography': 'Longevity & Geography',
+}

package/src/planner/learnLinks.ts

@@ -0,0 +1,85 @@
+/**
+ * Canonical Learning Center targets used by planner field help (V9 PR3).
+ *
+ * Centralizing the planner→article wiring here gives the contextual "Learn
+ * more" links a single source of truth and a broken-slug test (every hook must
+ * resolve to a `ready` article). Field help should reference these hooks rather
+ * than inlining raw slugs, so a typo or a not-yet-written article is caught by
+ * a test instead of shipping a dead link.
+ *
+ * Only add an entry once the target article is readable. Screen-level clusters
+ * use {@link articlesForRoute} instead and need no entry here.
+ */
+
+import type { LearnHook } from '../learn/LearnLink'
+
+export const LEARN = {
+  exampleCouple: { slug: 'example-couple', label: 'Learn about this example' },
+  exampleUnderSavedSingle: { slug: 'example-under-saved-single', label: 'Learn about this example' },
+  exampleBracketFillRoth: { slug: 'example-bracket-fill-roth', label: 'Learn about this example' },
+  exampleEarlyRetireeAca: { slug: 'example-early-retiree-aca', label: 'Learn about this example' },
+  exampleRmdIrmaa: { slug: 'example-rmd-irmaa', label: 'Learn about this example' },
+  exampleSurvivorYears: { slug: 'example-survivor-years', label: 'Learn about this example' },
+  exampleMovingStateTax: { slug: 'example-moving-state-tax', label: 'Learn about this example' },
+  exampleLtcShock: { slug: 'example-ltc-shock', label: 'Learn about this example' },
+  exampleGuardrailsFlex: { slug: 'example-guardrails-flex-goals', label: 'Learn about this example' },
+  exampleAnnuityEstate: { slug: 'example-annuity-purchases-estate', label: 'Learn about this example' },
+  exampleGlidepathAllocation: { slug: 'example-glidepath-allocation', label: 'Learn about this example' },
+  exampleHsaPropertyDepth: { slug: 'example-hsa-property-depth', label: 'Learn about this example' },
+  exampleFixedTargetSpending: { slug: 'example-fixed-target-spending', label: 'Learn about this example' },
+  exampleNoAnnuityBrokerage: { slug: 'example-no-annuity-brokerage', label: 'Learn about this example' },
+  exampleStaticAllocationControl: { slug: 'example-static-allocation-control', label: 'Learn about this example' },
+  exampleBrokerageNoHsa: { slug: 'example-brokerage-no-hsa', label: 'Learn about this example' },
+  withdrawalOrder: { slug: 'withdrawal-order-basics', label: 'Learn about withdrawal order' },
+  qcd: { slug: 'qcds-qualified-charitable-distributions', label: 'Learn about QCDs' },
+  itemizedDeductions: {
+    slug: 'standard-deduction-senior-deduction-and-itemizing',
+    label: 'Learn: standard vs. itemized deductions',
+  },
+  spendingBudget: { slug: 'building-a-retirement-spending-budget', label: 'Learn about retirement spending budgets' },
+  spendingProfiles: {
+    slug: 'spending-profiles-and-the-retirement-smile',
+    label: 'Learn about spending profiles',
+  },
+  survivorSpending: { slug: 'survivor-spending-in-couple-plans', label: 'Learn about survivor spending' },
+  sustainableSpending: { slug: 'how-much-can-i-spend', label: 'Learn: how much can I spend?' },
+  dynamicSpendingGuardrails: { slug: 'dynamic-spending-guardrails', label: 'Learn about spending flexibility' },
+  riskBasedGuardrails: { slug: 'risk-based-guardrails', label: 'Learn about risk-based guardrails' },
+  tipsLadders: { slug: 'tips-ladders', label: 'Learn about TIPS ladders' },
+  socialSecurityBridge: { slug: 'social-security-bridge', label: 'Learn about the Social Security bridge' },
+  fundedRatio: { slug: 'funded-ratio', label: 'Learn about the funded ratio' },
+  healthcareBefore65: { slug: 'healthcare-before-65', label: 'Learn about healthcare before 65' },
+  healthcareAfter65: { slug: 'healthcare-after-65', label: 'Learn about healthcare after 65' },
+  acaCredit: { slug: 'aca-premium-tax-credits-and-magi', label: 'Learn about ACA premium credits' },
+  ssa44: { slug: 'appealing-irmaa-ssa-44', label: 'Learn about SSA-44 IRMAA appeals' },
+  retirementHealthcareCosts: { slug: 'what-retirement-healthcare-really-costs', label: 'Learn what healthcare really costs' },
+  insuranceOverview: { slug: 'insurance-in-your-retirement-plan', label: 'Learn how insurance fits your plan' },
+  permanentLife: { slug: 'permanent-life-insurance-in-a-plan', label: 'Learn about permanent life insurance' },
+  ltcInsurance: { slug: 'long-term-care-insurance-as-risk-transfer', label: 'Learn about LTC insurance' },
+  ltcCosts: { slug: 'long-term-care-costs-and-insurance', label: 'Learn about long-term-care costs' },
+  rothConversionBasics: { slug: 'roth-conversion-basics', label: 'Learn about Roth conversions' },
+  fillingTaxBracket: { slug: 'filling-a-tax-bracket-with-roth-conversions', label: 'Learn: filling a tax bracket' },
+  marginalVsEffective: { slug: 'marginal-vs-effective-tax-rate', label: 'Learn: marginal vs effective rate' },
+  whyConversionsRaiseCosts: {
+    slug: 'why-roth-conversions-raise-other-costs',
+    label: 'Learn how conversions raise other costs',
+  },
+  todaysDollars: { slug: 'todays-dollars-vs-future-dollars', label: "Learn: today's vs future dollars" },
+  lossHarvesting: { slug: 'tax-loss-and-gain-harvesting', label: 'Learn about tax-loss harvesting' },
+  fiNumber: { slug: 'fi-number-and-four-percent-rule', label: 'Learn about FI number and SWR' },
+  accumulation: { slug: 'how-to-model-accumulation', label: 'Learn how to model accumulation' },
+  employerMatch: { slug: 'employer-match-and-contribution-order', label: 'Learn about employer match' },
+  ssTaxesVsBenefits: { slug: 'social-security-taxes-vs-benefits', label: 'Learn: Social Security taxes vs. benefits' },
+  generalInflation: { slug: 'assumption-general-inflation', label: 'Learn about general inflation' },
+  healthcareInflation: { slug: 'assumption-healthcare-inflation', label: 'Learn about healthcare inflation' },
+  investmentReturns: { slug: 'assumption-investment-returns', label: 'Learn about investment returns' },
+  ssCola: { slug: 'assumption-social-security-cola', label: 'Learn about Social Security COLA' },
+  ssTrustFund: { slug: 'assumption-social-security-trust-fund', label: 'Learn about the Social Security trust fund' },
+  longevity: { slug: 'assumption-longevity-planning-age', label: 'Learn about longevity planning age' },
+  stateTaxOverride: { slug: 'assumption-state-tax-override', label: 'Learn about the state tax override' },
+  stateIncomeTaxes: { slug: 'state-income-taxes-in-retirement', label: 'Learn about state income taxes in retirement' },
+  stateRelocation: { slug: 'what-changes-when-you-move-states', label: 'Learn what changes when you move states' },
+  recentMagi: { slug: 'assumption-recent-magi', label: 'Learn about recent MAGI' },
+  heirTaxRate: { slug: 'assumption-heir-tax-rate', label: 'Learn about the heir tax rate' },
+  optimizerObjectives: { slug: 'how-the-optimizer-thinks', label: 'Learn about optimizer objectives' },
+} as const satisfies Record<string, LearnHook>