Total Actions{mits.length}

Complete{mits.filter(m => m.status === 'Complete').length}

In Progress{mits.filter(m => m.status === 'In Progress' || m.status === 'Drafting').length}

Due ≤5 Days{dueSoon}

Avg Progress{avgProgress}%

{statuses.map(s => ( ))}

IDActionRiskAssigneePriorityDueProgress

{filtered.map((m, i) => { const daysUntil = Math.ceil((new Date(m.dueDate) - new Date('2026-04-20')) / 86400000); const isOverdue = m.status !== 'Complete' && daysUntil < 0; const isDueSoon = m.status !== 'Complete' && daysUntil >= 0 && daysUntil <= 3; return (

setHovered(i)} onMouseLeave={() => setHovered(null)}> {m.id}

{m.action}

{m.notes}

{m.riskId} {m.assignee} {m.priority} {m.dueDate.slice(5)} {isOverdue && overdue}

= 50 ? '#D97706' : '#6E7D9E' }} />

{m.progress}%

); })}

); } // ── SCENARIO ANALYSIS with interactive Monte Carlo (#7) ── function RiskScenarios({ data }) { const [expanded, setExpanded] = useState(null); const [hoveredBucket, setHoveredBucket] = useState(null); const [confidenceRange, setConfidenceRange] = useState([25, 75]); // percentile range const scenarios = data.scenarios; const reg = data.register; const mc = data.monteCarlo; const probColor = (p) => p >= 40 ? '#1B7A4A' : p >= 20 ? '#D97706' : '#6E7D9E'; // Map confidence range to dollar values const pctToValue = (pct) => { if (pct <= 10) return mc.p10; if (pct <= 25) return mc.p25; if (pct <= 50) return mc.median; if (pct <= 75) return mc.p75; return mc.p90; }; const confLow = pctToValue(confidenceRange[0]); const confHigh = pctToValue(confidenceRange[1]); return (

{/* Monte Carlo summary with interactivity */}

Monte Carlo Simulation — Case Valuation{mc.iterations.toLocaleString()} iterations

Expected Value

${(mc.expectedValue / 1e6).toFixed(1)}M

Median

${(mc.median / 1e6).toFixed(1)}M

P10

${(mc.p10 / 1e6).toFixed(1)}M

P25

${(mc.p25 / 1e6).toFixed(1)}M

P75

${(mc.p75 / 1e6).toFixed(1)}M

P90

${(mc.p90 / 1e6).toFixed(1)}M

{/* Interactive distribution bars */}

{mc.distribution.map((d, i) => { const isHovered = hoveredBucket === i; const isMedian = i === 5; // Highlight confidence interval buckets const bucketPctStart = mc.distribution.slice(0, i).reduce((s, b) => s + b.pct, 0); const bucketPctEnd = bucketPctStart + d.pct; const inConfidence = bucketPctStart < confidenceRange[1] && bucketPctEnd > confidenceRange[0]; return (

setHoveredBucket(i)} onMouseLeave={() => setHoveredBucket(null)}> {isHovered && (

{d.bucket}: {d.pct}% probability
≈ {Math.round(mc.iterations * d.pct / 100).toLocaleString()} iterations

)} {d.pct}%

); })}

{mc.distribution.map((d, i) => (

{d.bucket}

))}

{/* Confidence interval selector */}

Confidence Interval P{confidenceRange[0]}–P{confidenceRange[1]}: ${(confLow / 1e6).toFixed(1)}M – ${(confHigh / 1e6).toFixed(1)}M

Low setConfidenceRange([parseInt(e.target.value), Math.max(parseInt(e.target.value) + 10, confidenceRange[1])])} style={{ flex: 1, accentColor: rk.crimson }} /> P{confidenceRange[0]} High setConfidenceRange([Math.min(parseInt(e.target.value) - 10, confidenceRange[0]), parseInt(e.target.value)])} style={{ flex: 1, accentColor: rk.crimson }} /> P{confidenceRange[1]}

{/* Scenario cards */} {scenarios.map((sc, i) => (

setExpanded(expanded === i ? null : i)}>

{sc.id} {sc.name} {sc.probability}%

{sc.damages} {sc.timeline}

{expanded === i && (

{sc.outcome}

Key Assumptions

{sc.assumptions.map((a, j) => (

• {a}

))}

Key Risks

{sc.risks.map((rId, j) => { const risk = reg.find(r => r.id === rId); return risk ? (

{rId} {risk.name}

) : null; })}

)}

))}

); } // ── COMPLIANCE with countdown & heatmap (#12) ── function RiskCompliance({ data }) { const [hovered, setHovered] = useState(null); const comp = data.compliance; const now = new Date('2026-04-20'); const statusColor = { Active: '#1B7A4A', Upcoming: '#3B82F6', 'At Risk': '#C23030', Pending: '#D97706' }; const atRisk = comp.filter(c => c.status === 'At Risk').length; const upcoming = comp.filter(c => c.status === 'Upcoming').length; // Build deadline heatmap for next 30 days const deadlineMap = {}; comp.forEach(c => { if (c.dueDate) { const day = c.dueDate.slice(8, 10); if (!deadlineMap[c.dueDate]) deadlineMap[c.dueDate] = []; deadlineMap[c.dueDate].push(c); } if (c.nextVerification) { if (!deadlineMap[c.nextVerification]) deadlineMap[c.nextVerification] = []; deadlineMap[c.nextVerification].push({ ...c, isVerification: true }); } }); // Generate next 30 days const days30 = Array.from({ length: 30 }, (_, i) => { const d = new Date('2026-04-20'); d.setDate(d.getDate() + i); return d.toISOString().slice(0, 10); }); return (

Total Obligations{comp.length}

Active{comp.filter(c => c.status === 'Active').length}

At Risk{atRisk}

Upcoming{upcoming}

{/* Countdown widgets for urgent items */} {(() => { const urgent = comp.filter(c => c.dueDate && c.status !== 'Active').filter(c => { const d = Math.ceil((new Date(c.dueDate) - now) / 86400000); return d >= 0 && d <= 14; }).sort((a, b) => a.dueDate.localeCompare(b.dueDate)); if (urgent.length === 0) return null; return (

{urgent.map(c => { const daysLeft = Math.ceil((new Date(c.dueDate) - now) / 86400000); const urgencyColor = daysLeft <= 3 ? '#C23030' : daysLeft <= 7 ? '#D97706' : '#3B82F6'; return (

{c.obligation}

{c.matter} · {c.owner}

{daysLeft}

days left

); })}

); })()} {/* Deadline heatmap - next 30 days */}

Deadline Heatmap — Next 30 Days

{days30.map((day, i) => { const items = deadlineMap[day] || []; const hasAtRisk = items.some(c => c.status === 'At Risk'); const hasItems = items.length > 0; const isToday = i === 0; const dayNum = day.slice(8, 10); const monthChange = i > 0 && day.slice(5, 7) !== days30[i - 1].slice(5, 7); return (

{monthChange &&

May

}

{dayNum} {hasItems &&

{items.slice(0, 3).map((_, j) => (

))}

}

); })}

At Risk

Scheduled

Today

{/* Table */}

Compliance Tracker

IDObligationMatterStatusOwnerDueNext Check

{comp.map((c, i) => { const dueDays = c.dueDate ? Math.ceil((new Date(c.dueDate) - now) / 86400000) : null; const isUrgent = dueDays !== null && dueDays <= 5 && dueDays >= 0; return (

setHovered(i)} onMouseLeave={() => setHovered(null)}> {c.id}

{c.obligation}

{c.notes}

{c.matter} {c.status} {c.owner} {c.dueDate ? c.dueDate.slice(5) : '—'} {c.nextVerification ? c.nextVerification.slice(5) : '—'}

); })}

{/* AI compliance insight */}

◆ AI Compliance Alert

Insurance carrier supplemental notice (CO-06) due in 5 days — high risk of coverage denial if missed. Q1 client reports (CO-07) due April 30 across all matters. Conflict check for Whitfield referral (CO-08) should be prioritized before engagement letter deadline.

); } // ── RISK ANALYTICS ── function RiskAnalytics({ data }) { const reg = data.register; const mits = data.mitigations; const matterExposure = {}; reg.forEach(r => { if (!matterExposure[r.matter]) matterExposure[r.matter] = { count: 0, totalScore: 0, maxScore: 0 }; matterExposure[r.matter].count++; matterExposure[r.matter].totalScore += r.score; matterExposure[r.matter].maxScore = Math.max(matterExposure[r.matter].maxScore, r.score); }); const ownerLoad = {}; reg.forEach(r => { if (!ownerLoad[r.owner]) ownerLoad[r.owner] = { risks: 0, criticalRisks: 0, mitigations: 0 }; ownerLoad[r.owner].risks++; if (r.score >= 15) ownerLoad[r.owner].criticalRisks++; }); mits.forEach(m => { if (!ownerLoad[m.assignee]) ownerLoad[m.assignee] = { risks: 0, criticalRisks: 0, mitigations: 0 }; ownerLoad[m.assignee].mitigations++; }); const avgReduction = (reg.reduce((s, r) => s + (r.score - r.residualScore), 0) / reg.length).toFixed(1); const mitigationRate = Math.round((mits.filter(m => m.progress > 0).length / mits.length) * 100); return (

Portfolio Score{reg.reduce((s, r) => s + r.score, 0)}

Residual Score{reg.reduce((s, r) => s + r.residualScore, 0)}

Avg Reduction-{avgReduction}

Mitigation Rate{mitigationRate}%

Risk Velocity+{reg.filter(r => r.trend === 'rising').length}

Exposure by Matter

{Object.entries(matterExposure).sort((a, b) => b[1].totalScore - a[1].totalScore).map(([matter, exp]) => (

{matter} {exp.count} risks

{exp.totalScore}

))}

Risk Owner Workload

{Object.entries(ownerLoad).map(([owner, load]) => (

{owner}

{load.risks} risks {load.criticalRisks} critical {load.mitigations} actions

))}

{/* Inherent vs Residual */}

Inherent vs. Residual Risk — All Items

{[...reg].sort((a, b) => b.score - a.score).map((r) => (

{r.id} {r.name}

{r.score} → {r.residualScore}

))}

Inherent

Residual

); } // ── AUDIT LOG with filters + diff view (#13) ── function RiskAuditLog({ data }) { const [userFilter, setUserFilter] = useState('All'); const [riskFilter, setRiskFilter] = useState(''); const [dateFrom, setDateFrom] = useState(''); const log = data.auditLog; const users = ['All', ...new Set(log.map(l => l.user))]; const filtered = useMemo(() => { let items = log; if (userFilter !== 'All') items = items.filter(l => l.user === userFilter); if (riskFilter) { const q = riskFilter.toLowerCase(); items = items.filter(l => l.action.toLowerCase().includes(q) || l.detail.toLowerCase().includes(q)); } if (dateFrom) items = items.filter(l => l.date >= dateFrom); return items; }, [userFilter, riskFilter, dateFrom, log]); // Parse score diffs from detail strings const parseDiff = (detail) => { const match = detail.match(/(\d+)\s*→\s*(\d+)/); if (match) return { from: parseInt(match[1]), to: parseInt(match[2]) }; return null; }; return (

{/* Filters */}

setRiskFilter(e.target.value)} /> {users.map(u => ( ))}

From: setDateFrom(e.target.value)} /> {filtered.length} of {log.length} entries

Risk Assessment Audit Trail

{filtered.map((l, i) => { const diff = parseDiff(l.detail); return (

{l.date}

{l.user}

{l.action}

{l.detail}

{/* Diff visualization */} {diff && (

{diff.from} → {diff.to} diff.from ? '#C23030' : diff.to < diff.from ? '#1B7A4A' : T.color.text.tertiary }}> {diff.to > diff.from ? `+${diff.to - diff.from}` : diff.to < diff.from ? `${diff.to - diff.from}` : '='}

)}

); })} {filtered.length === 0 && (

No matching audit entries.

)}

); } Object.assign(window, { RiskMitigations, RiskScenarios, RiskCompliance, RiskAnalytics, RiskAuditLog });