fixed a lot of bugs, centralized schema

app/evaluation/[id]/page.client.tsx

@@ -6,9 +6,8 @@ import { Button } from "@/components/ui/button"
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
 import { Badge } from "@/components/ui/badge"
 import { ArrowLeft, Download, Eye, EyeOff } from "lucide-react"
-import { CATEGORIES } from "@/lib/category-data"
+import { getAllCategories, getCategoryById, getBenchmarkQuestions, getProcessQuestions } from "@/lib/schema"
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip"
-import { BENCHMARK_QUESTIONS, PROCESS_QUESTIONS } from "@/lib/category-data"
 import { naReasonForCategoryFromEval } from "@/lib/na-utils"
 
 const loadEvaluationDetails = async (id: string) => {
@@ -50,12 +49,12 @@ export default function EvaluationDetailsPage() {
   const toggleCategoryVisibility = (id: string) => setVisibleCategories((p) => ({ ...p, [id]: !p[id] }))
   const selectAll = () => {
   const map: Record<string, boolean> = {}
-  CATEGORIES.forEach((c) => (map[c.id] = true))
+  getAllCategories().forEach((c) => (map[c.id] = true))
   setVisibleCategories(map)
   }
   const deselectAll = () => {
   const map: Record<string, boolean> = {}
-  CATEGORIES.forEach((c) => (map[c.id] = false))
+  getAllCategories().forEach((c) => (map[c.id] = false))
   setVisibleCategories(map)
   }
 
@@ -77,7 +76,7 @@ export default function EvaluationDetailsPage() {
     if (evaluation) {
       const init: Record<string, boolean> = {}
       // default: eyes open (visible) for all categories unless explicitly NA
-      CATEGORIES.forEach((c) => {
+      getAllCategories().forEach((c) => {
         const na = naReasonForCategory(c.id)
         init[c.id] = !na
       })
@@ -90,11 +89,47 @@ export default function EvaluationDetailsPage() {
   const naReasonForCategory = (categoryId: string): string | undefined => {
     const catEval = evaluation?.categoryEvaluations?.[categoryId]
     if (!catEval) return undefined
-    const benchmarkQs = BENCHMARK_QUESTIONS.map((q) => q.id)
-    const processQs = PROCESS_QUESTIONS.map((q) => q.id)
+  const benchmarkQs = getBenchmarkQuestions().map((q) => q.id)
+  const processQs = getProcessQuestions().map((q) => q.id)
     return naReasonForCategoryFromEval(catEval, benchmarkQs, processQs)
   }
 
+  // Compute overall stats from evaluation data dynamically
+  const computedStats = (() => {
+    const strongCategories: string[] = []
+    const adequateCategories: string[] = []
+    const weakCategories: string[] = []
+    const insufficientCategories: string[] = []
+
+    const allEntries = evaluation?.categoryEvaluations || {}
+    for (const [catId, catData] of Object.entries(allEntries)) {
+      // Count yes/no across A & B
+      let yes = 0
+      let no = 0
+      let na = 0
+      const bQs = getBenchmarkQuestions().map((q) => q.id)
+      const pQs = getProcessQuestions().map((q) => q.id)
+      for (const qid of [...bQs, ...pQs]) {
+        const raw = (catData as any).benchmarkAnswers?.[qid] ?? (catData as any).processAnswers?.[qid]
+        const arr = Array.isArray(raw) ? raw : raw ? [raw] : []
+        const hasYes = arr.some((a: string) => String(a).toLowerCase() === "yes")
+        const hasNo = arr.some((a: string) => String(a).toLowerCase() === "no")
+        if (hasYes) yes++
+        else if (hasNo) no++
+        else na++
+      }
+
+      const totalApplicable = yes + no
+      const ratio = totalApplicable > 0 ? yes / totalApplicable : 0
+      if (ratio >= 0.8) strongCategories.push(catId)
+      else if (ratio >= 0.6) adequateCategories.push(catId)
+      else if (ratio >= 0.4) weakCategories.push(catId)
+      else insufficientCategories.push(catId)
+    }
+
+    return { strongCategories, adequateCategories, weakCategories, insufficientCategories }
+  })()
+
   useEffect(() => {
     try {
       localStorage.setItem(STORAGE_KEY, JSON.stringify(visibleCategories))
@@ -197,7 +232,7 @@ export default function EvaluationDetailsPage() {
               {/* compute applicable count as non-NA categories from the full CATEGORIES list */}
               <CardTitle>
                 Applicable Categories ({
-                  CATEGORIES.filter((c) => {
+                  getAllCategories().filter((c) => {
                     const sel = new Set(evaluation.selectedCategories || [])
                     // treat as applicable only when selected and not explicitly NA
                     const na = naReasonForCategory(c.id)
@@ -220,7 +255,7 @@ export default function EvaluationDetailsPage() {
             <div>
               <div className="text-sm font-medium mb-2">Capabilities</div>
               <div className="flex flex-col gap-2">
-                {CATEGORIES.filter((c: any) => c.type === "capability").map((category: any) => {
+                {getAllCategories().filter((c) => c.type === "capability").map((category) => {
                     const sel = new Set(evaluation.selectedCategories || [])
                     const naReason = naReasonForCategory(category.id)
                     const isSelected = sel.has(category.id)
@@ -256,14 +291,14 @@ export default function EvaluationDetailsPage() {
                         )}
                         <span className="ml-2">
                           {isNA ? (
-                            <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-muted/30 text-muted-foreground border-2 border-purple-500">
-                              {category.name}
-                            </span>
-                          ) : (
-                            <Badge variant="secondary" className="cursor-pointer">
-                              {category.name}
-                            </Badge>
-                          )}
+                              <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-muted/30 text-muted-foreground border-2 border-purple-500">
+                                {getCategoryById(category.id)?.name || category.name}
+                              </span>
+                            ) : (
+                              <Badge variant="secondary" className="cursor-pointer">
+                                {getCategoryById(category.id)?.name || category.name}
+                              </Badge>
+                            )}
                         </span>
                       </label>
                     )
@@ -274,7 +309,7 @@ export default function EvaluationDetailsPage() {
             <div>
               <div className="text-sm font-medium mb-2">Risks</div>
               <div className="flex flex-col gap-2">
-                {CATEGORIES.filter((c: any) => c.type === "risk").map((category: any) => {
+                {getAllCategories().filter((c) => c.type === "risk").map((category) => {
                     const sel = new Set(evaluation.selectedCategories || [])
                     const naReason = naReasonForCategory(category.id)
                     const isSelected = sel.has(category.id)
@@ -311,11 +346,11 @@ export default function EvaluationDetailsPage() {
                         <span className="ml-2">
                           {isNA ? (
                             <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-muted/30 text-muted-foreground border-2 border-red-500">
-                              {category.name}
+                              {getCategoryById(category.id)?.name || category.name}
                             </span>
                           ) : (
                             <Badge variant="destructive" className="cursor-pointer">
-                              {category.name}
+                              {getCategoryById(category.id)?.name || category.name}
                             </Badge>
                           )}
                         </span>
@@ -337,25 +372,25 @@ export default function EvaluationDetailsPage() {
           <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
             <div className="text-center p-4 bg-green-50 dark:bg-green-950 rounded-lg">
               <div className="text-2xl font-bold text-green-700 dark:text-green-300">
-                {evaluation.overallStats?.strongCategories?.length || 0}
+                {computedStats.strongCategories.length}
               </div>
               <div className="text-sm text-green-600 dark:text-green-400">Strong</div>
             </div>
             <div className="text-center p-4 bg-blue-50 dark:bg-blue-950 rounded-lg">
               <div className="text-2xl font-bold text-blue-700 dark:text-blue-300">
-                {evaluation.overallStats?.adequateCategories?.length || 0}
+                {computedStats.adequateCategories.length}
               </div>
               <div className="text-sm text-blue-600 dark:text-blue-400">Adequate</div>
             </div>
             <div className="text-center p-4 bg-yellow-50 dark:bg-yellow-950 rounded-lg">
               <div className="text-2xl font-bold text-yellow-700 dark:text-yellow-300">
-                {evaluation.overallStats?.weakCategories?.length || 0}
+                {computedStats.weakCategories.length}
               </div>
               <div className="text-sm text-yellow-600 dark:text-yellow-400">Weak</div>
             </div>
             <div className="text-center p-4 bg-red-50 dark:bg-red-950 rounded-lg">
               <div className="text-2xl font-bold text-red-700 dark:text-red-300">
-                {evaluation.overallStats?.insufficientCategories?.length || 0}
+                {computedStats.insufficientCategories.length}
               </div>
               <div className="text-sm text-red-600 dark:text-red-400">Insufficient</div>
             </div>
@@ -374,7 +409,7 @@ export default function EvaluationDetailsPage() {
               {[...(evaluation.overallStats?.insufficientCategories || []), ...(evaluation.overallStats?.weakCategories || [])]
                 .filter(Boolean)
                 .map((catId: string) => {
-                  const category = CATEGORIES.find((c) => c.id === catId)
+                  const category = getCategoryById(catId)
                   return (
                     <div key={catId} className="p-3 border rounded-md flex items-center justify-between">
                       <div>
@@ -400,17 +435,17 @@ export default function EvaluationDetailsPage() {
             const na = naReasonForCategory(categoryId)
             return !na && (visibleCategories[categoryId] ?? true)
           })
-          .map(([categoryId, data]: [string, any]) => {
-            const category = CATEGORIES.find((c) => c.id === categoryId)
+      .map(([categoryId, data]: [string, any]) => {
+    const category = getCategoryById(categoryId)
 
             // compute per-category score (yes out of applicable (yes+no)) across A & B
-            const benchmarkQs = BENCHMARK_QUESTIONS.map((q) => q.id)
-            const processQs = PROCESS_QUESTIONS.map((q) => q.id)
+            const benchmarkQs = getBenchmarkQuestions().map((q) => q.id)
+            const processQs = getProcessQuestions().map((q) => q.id)
             let yesCount = 0
             let noCount = 0
             let naCount = 0
 
-            for (const qid of benchmarkQs) {
+            for (const qid of getBenchmarkQuestions().map((q) => q.id)) {
               const raw = data.benchmarkAnswers?.[qid]
               const answers = Array.isArray(raw) ? raw : raw ? [raw] : []
               const hasYes = answers.some((a: string) => String(a).toLowerCase() === "yes")
@@ -422,7 +457,7 @@ export default function EvaluationDetailsPage() {
               else naCount++
             }
 
-            for (const qid of processQs) {
+            for (const qid of getProcessQuestions().map((q) => q.id)) {
               const raw = data.processAnswers?.[qid]
               const answers = Array.isArray(raw) ? raw : raw ? [raw] : []
               const hasYes = answers.some((a: string) => String(a).toLowerCase() === "yes")
@@ -437,10 +472,10 @@ export default function EvaluationDetailsPage() {
             const totalApplicable = yesCount + noCount
             const scoreText = totalApplicable > 0 ? `${yesCount}/${totalApplicable}` : "N/A"
             let rating = "Unknown"
-            if (evaluation.overallStats?.strongCategories?.includes(categoryId)) rating = "Strong"
-            else if (evaluation.overallStats?.adequateCategories?.includes(categoryId)) rating = "Adequate"
-            else if (evaluation.overallStats?.weakCategories?.includes(categoryId)) rating = "Weak"
-            else if (evaluation.overallStats?.insufficientCategories?.includes(categoryId)) rating = "Insufficient"
+            if (computedStats.strongCategories.includes(categoryId)) rating = "Strong"
+            else if (computedStats.adequateCategories.includes(categoryId)) rating = "Adequate"
+            else if (computedStats.weakCategories.includes(categoryId)) rating = "Weak"
+            else if (computedStats.insufficientCategories.includes(categoryId)) rating = "Insufficient"
 
             const ratingClass =
               rating === "Strong"
@@ -480,183 +515,128 @@ export default function EvaluationDetailsPage() {
                     <div>
                       <h4 className="font-semibold mb-3">Part A: Benchmark & Testing</h4>
                       <div className="space-y-4">
-                        {(() => {
-                          const entries = Object.entries(data.benchmarkSources || {}) as [string, any][]
-                          const yesItems: any[] = []
-                          const noItems: any[] = []
-                          const naItems: any[] = []
-
-                          // iterate the union of known source keys and answer keys so we show questions
-                          const canonicalKeys = BENCHMARK_QUESTIONS.map((q) => q.id)
-                          const answerKeys = Object.keys(data.benchmarkAnswers || {})
-                          const sourceKeys = Object.keys(data.benchmarkSources || {})
-                          const keySet = new Set<string>([...canonicalKeys, ...answerKeys, ...sourceKeys])
-                          for (const questionId of Array.from(keySet)) {
-                            const sources = data.benchmarkSources?.[questionId] || []
-                            const qText = BENCHMARK_QUESTIONS.find((x) => x.id === questionId)?.text || questionId
-                            const rawAnswer = data.benchmarkAnswers?.[questionId]
-                            const answers = Array.isArray(rawAnswer) ? rawAnswer : rawAnswer ? [rawAnswer] : []
-                            const hasYes = answers.some((a: string) => String(a).toLowerCase() === "yes")
-                            const hasNo = answers.some((a: string) => String(a).toLowerCase() === "no")
-                            const hasNA = answers.length === 0 || answers.some((a: string) => String(a).toLowerCase().includes("not applicable") || String(a).toLowerCase() === "n/a")
-
-                            const reason =
-                              sources?.[0]?.scope || sources?.[0]?.description || data.additionalAspects || (hasNA ? "Not applicable" : undefined)
-
-                            if (hasYes) yesItems.push({ questionId, qText, sources })
-                            else if (hasNo) noItems.push({ questionId, qText })
-                            else if (hasNA) naItems.push({ questionId, qText, reason })
-                            else naItems.push({ questionId, qText, reason: reason || "Not applicable" })
-                          }
+                        {getBenchmarkQuestions().map((q) => {
+                          const questionId = q.id
+                          const sources = data.benchmarkSources?.[questionId] || []
+                          const qText = q.text
+                          const rawAnswer = data.benchmarkAnswers?.[questionId]
+                          const answers = Array.isArray(rawAnswer) ? rawAnswer : rawAnswer ? [rawAnswer] : []
+                          const hasYes = answers.some((a: string) => String(a).toLowerCase() === "yes")
+                          const hasNo = answers.some((a: string) => String(a).toLowerCase() === "no")
+                          const hasNA = answers.length === 0 || answers.some((a: string) => String(a).toLowerCase().includes("not applicable") || String(a).toLowerCase() === "n/a")
+
+                          const key = `bench-${categoryId}-${questionId}`
 
                           return (
-                            <>
-                              {yesItems.map((it) => {
-                                const key = `bench-${categoryId}-${it.questionId}`
-                                return (
-                                  <div key={it.questionId} className="border rounded-lg p-4">
-                                    <div
-                                      role="button"
-                                      tabIndex={0}
-                                      onClick={() => toggleNegatives(key)}
-                                      className="flex items-center gap-2 mb-2 justify-between cursor-pointer"
-                                    >
-                                      <div className="flex items-center gap-3">
-                                        <span className="font-medium">{it.questionId}:</span>
-                                        <div className="text-sm">{it.qText}</div>
-                                      </div>
-                                      <div className="flex items-center gap-2">
-                                        <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-green-100 text-green-700">yes</span>
-                                      </div>
-                                    </div>
-
-                                    {expandedNegatives[key] && (() => {
-                                      const cards = (it.sources || []).flatMap((src: any) => {
-                                        const names = String(src.benchmarkName || '')
-                                          .split(',')
-                                          .map((s: string) => s.trim())
-                                          .filter(Boolean)
-
-                                        const scoreParts = String(src.score || '')
-                                          .split(',')
-                                          .map((s: string) => s.trim())
-                                          .filter(Boolean)
-
-                                        return (names.length > 0 ? names : ['Benchmark']).map((name: string, idx: number) => {
-                                          // determine score for this benchmark (positional or by name) or fallback to any numeric
-                                          let scoreNum: number | undefined
-                                          if (scoreParts.length === names.length && scoreParts[idx]) {
-                                            const m = scoreParts[idx].match(/(\d+(?:\.\d+)?)/)
-                                            if (m) scoreNum = parseFloat(m[1])
-                                          } else if (scoreParts.length > 0) {
-                                            const byName = scoreParts.find((p: string) => p.toLowerCase().includes(name.toLowerCase()))
-                                            const m = (byName || scoreParts[0]).match(/(\d+(?:\.\d+)?)/)
-                                            if (m) scoreNum = parseFloat(m[1])
-                                          } else if (src?.score) {
-                                            const m = String(src.score).match(/(\d+(?:\.\d+)?)/)
-                                            if (m) scoreNum = parseFloat(m[1])
-                                          }
-
-                                          return (
-                                            <div key={`${it.questionId}-${name}-${idx}`} className="p-4 border rounded-lg bg-background">
-                                              <div className="flex items-start justify-between">
-                                                <div className="text-xs inline-flex items-center rounded-full px-2 py-1 bg-indigo-50 text-indigo-700">Percentage</div>
-                                                <div className="text-2xl font-bold text-indigo-600">{scoreNum != null ? `${scoreNum}%` : '—'}</div>
-                                              </div>
-
-                                              <div className="mt-3 text-lg font-semibold">{name}</div>
-
-                                              {scoreNum != null && (
-                                                <div className="mt-3">
-                                                  <div className="h-2 bg-gray-200 rounded-full overflow-hidden">
-                                                    <div className="h-2 bg-indigo-500" style={{ width: `${Math.max(0, Math.min(100, scoreNum))}%` }} />
-                                                  </div>
-                                                </div>
-                                              )}
-
-                                              <div className="mt-3 space-y-2 text-sm">
-                                                <div>
-                                                  <span className="text-muted-foreground">Source:</span>{' '}
-                                                  {src.url ? (
-                                                    <a className="text-primary underline" href={src.url} target="_blank" rel="noreferrer">
-                                                      {src.url}
-                                                    </a>
-                                                  ) : (
-                                                    '—'
-                                                  )}
-                                                </div>
-                                                <div>
-                                                  <span className="text-muted-foreground">Type:</span> {src.sourceType || src.documentType || '—'}
-                                                </div>
-                                                {src.metrics && (
-                                                  <div>
-                                                    <span className="text-muted-foreground">Metric:</span> {src.metrics}
-                                                  </div>
-                                                )}
-                                                {src.confidenceInterval && (
-                                                  <div>
-                                                    <span className="text-muted-foreground">Confidence Interval:</span> {src.confidenceInterval}
-                                                  </div>
-                                                )}
-                                                {src.description && (
-                                                  <div className="mt-2 p-2 bg-muted/40 rounded text-sm">{src.description}</div>
-                                                )}
-                                              </div>
-                                            </div>
-                                          )
-                                        })
-                                      })
-
-                                      if (cards.length === 0) return <div className="text-sm text-muted-foreground">No benchmark details available.</div>
-
-                                      return <div className="mt-3 grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">{cards}</div>
-                                    })()}
-                                  </div>
-                                )
-                              })}
-
-                              {noItems.map((it) => (
-                                <div key={it.questionId} className="border rounded-lg p-4">
-                                  <div className="flex items-center gap-2 mb-2 justify-between">
-                                    <div className="flex items-center gap-3">
-                                      <span className="font-medium">{it.questionId}:</span>
-                                      <div className="text-sm">{it.qText}</div>
-                                    </div>
-                                    <div>
-                                      <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-red-100 text-red-700">no</span>
-                                    </div>
-                                  </div>
+                            <div key={questionId} className="border rounded-lg p-4">
+                              <div
+                                role="button"
+                                tabIndex={0}
+                                onClick={() => toggleNegatives(key)}
+                                className="flex items-center gap-2 mb-2 justify-between cursor-pointer"
+                              >
+                                <div className="flex items-center gap-3">
+                                  <span className="font-medium">{questionId}:</span>
+                                  <div className="text-sm">{qText}</div>
                                 </div>
-                              ))}
-
-                              {naItems.length > 0 && (
-                                <div className="border rounded-lg p-3">
-                                  <div className="flex items-center justify-between">
-                                    <div className="font-medium">Not applicable ({naItems.length})</div>
-                                    <button onClick={() => toggleNegatives(`bench-na-${categoryId}`)} className="text-sm text-primary underline">
-                                      {expandedNegatives[`bench-na-${categoryId}`] ? "Hide" : "Show"}
-                                    </button>
-                                  </div>
-
-                                  {expandedNegatives[`bench-na-${categoryId}`] && (
-                                    <div className="mt-3 space-y-2">
-                                      {naItems.map((it) => (
-                                        <div key={it.questionId} className="p-2 bg-muted rounded">
-                                          <div className="flex items-center justify-between">
-                                            <div className="text-sm">
-                                              <span className="font-medium">{it.questionId}:</span> {it.qText}
+                                <div className="flex items-center gap-2">
+                                  {hasYes ? (
+                                    <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-green-100 text-green-700">yes</span>
+                                  ) : hasNo ? (
+                                    <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-red-100 text-red-700">no</span>
+                                  ) : (
+                                    <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-muted/20 text-muted-foreground">n/a</span>
+                                  )}
+                                </div>
+                              </div>
+
+                              {hasYes && expandedNegatives[key] && (() => {
+                                const cards = (sources || []).flatMap((src: any) => {
+                                  const names = String(src.benchmarkName || '')
+                                    .split(',')
+                                    .map((s: string) => s.trim())
+                                    .filter(Boolean)
+
+                                  const scoreParts = String(src.score || '')
+                                    .split(',')
+                                    .map((s: string) => s.trim())
+                                    .filter(Boolean)
+
+                                  return (names.length > 0 ? names : ['Benchmark']).map((name: string, idx: number) => {
+                                    let scoreNum: number | undefined
+                                    if (scoreParts.length === names.length && scoreParts[idx]) {
+                                      const m = scoreParts[idx].match(/(\d+(?:\.\d+)?)/)
+                                      if (m) scoreNum = parseFloat(m[1])
+                                    } else if (scoreParts.length > 0) {
+                                      const byName = scoreParts.find((p: string) => p.toLowerCase().includes(name.toLowerCase()))
+                                      const m = (byName || scoreParts[0]).match(/(\d+(?:\.\d+)?)/)
+                                      if (m) scoreNum = parseFloat(m[1])
+                                    } else if (src?.score) {
+                                      const m = String(src.score).match(/(\d+(?:\.\d+)?)/)
+                                      if (m) scoreNum = parseFloat(m[1])
+                                    }
+
+                                    return (
+                                      <div key={`${questionId}-${name}-${idx}`} className="p-4 border rounded-lg bg-background">
+                                        <div className="flex items-start justify-between">
+                                          <div className="text-xs inline-flex items-center rounded-full px-2 py-1 bg-indigo-50 text-indigo-700">Percentage</div>
+                                          <div className="text-2xl font-bold text-indigo-600">{scoreNum != null ? `${scoreNum}%` : '—'}</div>
+                                        </div>
+
+                                        <div className="mt-3 text-lg font-semibold">{name}</div>
+
+                                        {scoreNum != null && (
+                                          <div className="mt-3">
+                                            <div className="h-2 bg-gray-200 rounded-full overflow-hidden">
+                                              <div className="h-2 bg-indigo-500" style={{ width: `${Math.max(0, Math.min(100, scoreNum))}%` }} />
                                             </div>
-                                            <div className="text-xs text-muted-foreground">Reason: {it.reason}</div>
                                           </div>
+                                        )}
+
+                                        <div className="mt-3 space-y-2 text-sm">
+                                          <div>
+                                            <span className="text-muted-foreground">Source:</span>{' '}
+                                            {src.url ? (
+                                              <a className="text-primary underline" href={src.url} target="_blank" rel="noreferrer">
+                                                {src.url}
+                                              </a>
+                                            ) : (
+                                              '—'
+                                            )}
+                                          </div>
+                                          <div>
+                                            <span className="text-muted-foreground">Type:</span> {src.sourceType || src.documentType || '—'}
+                                          </div>
+                                          {src.metrics && (
+                                            <div>
+                                              <span className="text-muted-foreground">Metric:</span> {src.metrics}
+                                            </div>
+                                          )}
+                                          {src.confidenceInterval && (
+                                            <div>
+                                              <span className="text-muted-foreground">Confidence Interval:</span> {src.confidenceInterval}
+                                            </div>
+                                          )}
+                                          {src.description && (
+                                            <div className="mt-2 p-2 bg-muted/40 rounded text-sm">{src.description}</div>
+                                          )}
                                         </div>
-                                      ))}
-                                    </div>
-                                  )}
-                                </div>
+                                      </div>
+                                    )
+                                  })
+                                })
+
+                                if (cards.length === 0) return <div className="text-sm text-muted-foreground">No benchmark details available.</div>
+
+                                return <div className="mt-3 grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">{cards}</div>
+                              })()}
+
+                              {hasNA && (
+                                <div className="mt-2 text-sm text-muted-foreground">Reason: {sources?.[0]?.description || data.additionalAspects || 'Not applicable'}</div>
                               )}
-                            </>
+                            </div>
                           )
-                        })()}
+                        })}
                       </div>
                     </div>
                   )}
@@ -666,121 +646,69 @@ export default function EvaluationDetailsPage() {
                     <div>
                       <h4 className="font-semibold mb-3">Part B: Documentation & Process</h4>
                       <div className="space-y-4">
-                        {(() => {
-                          const entries = Object.entries(data.processSources || {}) as [string, any][]
-                          const yesItems: any[] = []
-                          const noItems: any[] = []
-                          const naItems: any[] = []
-
-                          const canonicalKeys = PROCESS_QUESTIONS.map((q) => q.id)
-                          const answerKeys = Object.keys(data.processAnswers || {})
-                          const sourceKeys = Object.keys(data.processSources || {})
-                          const keySet = new Set<string>([...canonicalKeys, ...answerKeys, ...sourceKeys])
-                          for (const questionId of Array.from(keySet)) {
-                            const sources = data.processSources?.[questionId] || []
-                            const qText = PROCESS_QUESTIONS.find((x) => x.id === questionId)?.text || questionId
-                            const rawAnswer = data.processAnswers?.[questionId]
-                            const answers = Array.isArray(rawAnswer) ? rawAnswer : rawAnswer ? [rawAnswer] : []
-                            const hasYes = answers.some((a: string) => String(a).toLowerCase() === "yes")
-                            const hasNo = answers.some((a: string) => String(a).toLowerCase() === "no")
-                            const hasNA = answers.length === 0 || answers.some((a: string) => String(a).toLowerCase().includes("not applicable") || String(a).toLowerCase() === "n/a")
-
-                            const reason = sources?.[0]?.scope || sources?.[0]?.description || data.additionalAspects || (hasNA ? "Not applicable" : undefined)
-
-                            if (hasYes) yesItems.push({ questionId, qText, sources })
-                            else if (hasNo) noItems.push({ questionId, qText })
-                            else if (hasNA) naItems.push({ questionId, qText, reason })
-                            else naItems.push({ questionId, qText, reason: reason || "Not applicable" })
-                          }
+                        {getProcessQuestions().map((q) => {
+                          const questionId = q.id
+                          const sources = data.processSources?.[questionId] || []
+                          const qText = q.text
+                          const rawAnswer = data.processAnswers?.[questionId]
+                          const answers = Array.isArray(rawAnswer) ? rawAnswer : rawAnswer ? [rawAnswer] : []
+                          const hasYes = answers.some((a: string) => String(a).toLowerCase() === "yes")
+                          const hasNo = answers.some((a: string) => String(a).toLowerCase() === "no")
+                          const hasNA = answers.length === 0 || answers.some((a: string) => String(a).toLowerCase().includes("not applicable") || String(a).toLowerCase() === "n/a")
+
+                          const key = `proc-${categoryId}-${questionId}`
 
                           return (
-                            <>
-                              {yesItems.map((it) => {
-                                const key = `proc-${categoryId}-${it.questionId}`
-                                return (
-                                  <div key={it.questionId} className="border rounded-lg p-4">
-                                    <div
-                                      role="button"
-                                      tabIndex={0}
-                                      onClick={() => toggleNegatives(key)}
-                                      className="flex items-center gap-2 mb-2 justify-between cursor-pointer"
-                                    >
-                                      <div className="flex items-center gap-3">
-                                        <span className="font-medium">{it.questionId}:</span>
-                                        <div className="text-sm">{it.qText}</div>
-                                      </div>
-                                      <div className="flex items-center gap-2">
-                                          <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-green-100 text-green-700">yes</span>
+                            <div key={questionId} className="border rounded-lg p-4">
+                              <div
+                                role="button"
+                                tabIndex={0}
+                                onClick={() => toggleNegatives(key)}
+                                className="flex items-center gap-2 mb-2 justify-between cursor-pointer"
+                              >
+                                <div className="flex items-center gap-3">
+                                  <span className="font-medium">{questionId}:</span>
+                                  <div className="text-sm">{qText}</div>
+                                </div>
+                                <div className="flex items-center gap-2">
+                                  {hasYes ? (
+                                    <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-green-100 text-green-700">yes</span>
+                                  ) : hasNo ? (
+                                    <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-red-100 text-red-700">no</span>
+                                  ) : (
+                                    <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-muted/20 text-muted-foreground">n/a</span>
+                                  )}
+                                </div>
+                              </div>
+
+                              {hasYes && expandedNegatives[key] && (
+                                <div className="mt-3 space-y-3">
+                                  {(sources || []).map((src: any, i: number) => (
+                                    <div key={i} className="p-3 bg-muted rounded">
+                                      <div className="grid grid-cols-1 gap-2 text-sm">
+                                        <div>
+                                          <span className="text-muted-foreground">URL:</span> {src?.url || '—'}
+                                        </div>
+                                        <div>
+                                          <span className="text-muted-foreground">Document Type:</span> {src?.documentType || src?.sourceType || '—'}
                                         </div>
-                                    </div>
-
-                                    {expandedNegatives[key] && (
-                                      <div className="mt-3 space-y-3">
-                                        {(it.sources || []).map((src: any, i: number) => (
-                                          <div key={i} className="p-3 bg-muted rounded">
-                                            <div className="grid grid-cols-1 gap-2 text-sm">
-                                              <div>
-                                                <span className="text-muted-foreground">URL:</span> {src?.url || '—'}
-                                              </div>
-                                              <div>
-                                                <span className="text-muted-foreground">Document Type:</span> {src?.documentType || src?.sourceType || '—'}
-                                              </div>
-                                            </div>
-                                            {src?.description && (
-                                              <div className="mt-2 text-sm">
-                                                <span className="text-muted-foreground">Description:</span> {src.description}
-                                              </div>
-                                            )}
-                                          </div>
-                                        ))}
                                       </div>
-                                    )}
-                                  </div>
-                                )
-                              })}
-
-                              {noItems.map((it) => (
-                                <div key={it.questionId} className="border rounded-lg p-4">
-                                  <div className="flex items-center gap-2 mb-2 justify-between">
-                                    <div className="flex items-center gap-3">
-                                      <span className="font-medium">{it.questionId}:</span>
-                                      <div className="text-sm">{it.qText}</div>
-                                    </div>
-                                    <div>
-                                      <span className="inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium bg-red-100 text-red-700">no</span>
-                                    </div>
-                                  </div>
-                                </div>
-                              ))}
-
-                              {naItems.length > 0 && (
-                                <div className="border rounded-lg p-3">
-                                  <div className="flex items-center justify-between">
-                                    <div className="font-medium">Not applicable ({naItems.length})</div>
-                                    <button onClick={() => toggleNegatives(`proc-na-${categoryId}`)} className="text-sm text-primary underline">
-                                      {expandedNegatives[`proc-na-${categoryId}`] ? "Hide" : "Show"}
-                                    </button>
-                                  </div>
-
-                                  {expandedNegatives[`proc-na-${categoryId}`] && (
-                                    <div className="mt-3 space-y-2">
-                                      {naItems.map((it) => (
-                                        <div key={it.questionId} className="p-2 bg-muted rounded">
-                                          <div className="flex items-center justify-between">
-                                            <div className="text-sm">
-                                              <span className="font-medium">{it.questionId}:</span> {it.qText}
-                                            </div>
-                                            <div className="text-xs text-muted-foreground">Reason: {it.reason}</div>
-                                          </div>
+                                      {src?.description && (
+                                        <div className="mt-2 text-sm">
+                                          <span className="text-muted-foreground">Description:</span> {src.description}
                                         </div>
-                                      ))}
+                                      )}
                                     </div>
-                                  )}
+                                  ))}
                                 </div>
                               )}
-                            </>
+
+                              {hasNA && (
+                                <div className="mt-2 text-sm text-muted-foreground">Reason: {sources?.[0]?.description || data.additionalAspects || 'Not applicable'}</div>
+                              )}
+                            </div>
                           )
-                        })()}
+                        })}
                       </div>
                     </div>
                   )}

app/page.tsx

@@ -6,7 +6,7 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@
 import { Plus, Moon, Sun, Filter, ArrowUpDown } from "lucide-react"
 import { useTheme } from "next-themes"
 import { EvaluationCard, type EvaluationCardData } from "@/components/evaluation-card"
-import { BENCHMARK_QUESTIONS, PROCESS_QUESTIONS } from "@/lib/category-data"
+import { getBenchmarkQuestions, getProcessQuestions } from "@/lib/schema"
 import { AIEvaluationDashboard } from "@/components/ai-evaluation-dashboard"
 
 const loadEvaluationData = async (): Promise<EvaluationCardData[]> => {
@@ -36,7 +36,8 @@ const loadEvaluationData = async (): Promise<EvaluationCardData[]> => {
         id: data.id || `eval-${Date.now()}`,
         systemName: data.systemName || "Unknown System",
         provider: data.provider || "Unknown Provider",
-        modality: data.modality || "Unknown",
+        inputModalities: data.inputModalities || ["Text"],
+        outputModalities: data.outputModalities || ["Text"],
         completedDate: data.evaluationDate || new Date().toISOString().split("T")[0],
         applicableCategories: data.overallStats?.totalApplicable || 0,
         completedCategories: data.overallStats?.totalApplicable || 0,
@@ -323,7 +324,7 @@ const loadEvaluationData = async (): Promise<EvaluationCardData[]> => {
                 const isArray = Array.isArray(answer)
                 const negative = answer === "no" || (isArray && (answer as any[]).includes("no"))
                 const positive = answer === "yes" || (isArray && (answer as any[]).includes("yes"))
-                const qText = BENCHMARK_QUESTIONS.find((x) => x.id === qid)?.text || qid
+                const qText = getBenchmarkQuestions().find((x) => x.id === qid)?.text || qid
                 if (positive) yesList.push(qText)
                 if (negative) {
                   const status = naMeta ? "na" : "no"
@@ -339,7 +340,7 @@ const loadEvaluationData = async (): Promise<EvaluationCardData[]> => {
                 const isArray = Array.isArray(answer)
                 const negative = answer === "no" || (isArray && (answer as any[]).includes("no"))
                 const positive = answer === "yes" || (isArray && (answer as any[]).includes("yes"))
-                const qText = PROCESS_QUESTIONS.find((x) => x.id === qid)?.text || qid
+                const qText = getProcessQuestions().find((x) => x.id === qid)?.text || qid
                 if (positive) yesList.push(qText)
                 if (negative) {
                   const status = naMeta ? "na" : "no"
@@ -388,8 +389,12 @@ export default function HomePage() {
   }, [evaluationsData])
 
   const uniqueModalities = useMemo(() => {
-    const modalities = [...new Set(evaluationsData.map((item) => item.modality))].sort()
-    return modalities
+    const modalities = new Set<string>()
+    evaluationsData.forEach((item) => {
+      item.inputModalities.forEach((mod) => modalities.add(mod))
+      item.outputModalities.forEach((mod) => modalities.add(mod))
+    })
+    return [...modalities].sort()
   }, [evaluationsData])
 
   const filteredAndSortedEvaluations = useMemo(() => {
@@ -400,7 +405,10 @@ export default function HomePage() {
     }
 
     if (filterByModality !== "all") {
-      filtered = filtered.filter((item) => item.modality === filterByModality)
+      filtered = filtered.filter((item) => 
+        item.inputModalities.includes(filterByModality) || 
+        item.outputModalities.includes(filterByModality)
+      )
     }
 
     filtered = [...filtered].sort((a, b) => {

components/ai-evaluation-dashboard.tsx

@@ -10,15 +10,14 @@ import { CategorySelection } from "./category-selection"
 import { CategoryEvaluation } from "./category-evaluation"
 import { EvaluationForm } from "./evaluation-form"
 import { ResultsDashboard } from "./results-dashboard"
-import { CATEGORIES } from "@/lib/category-data"
+import { getAllCategories, getCategoryById } from "@/lib/schema"
 
 export type SystemInfo = {
   name: string
   url: string
   provider: string
-  systemTypes: string[]
+  version: string
   deploymentContexts: string[]
-  modality: string
   modelTag?: string
   knowledgeCutoff?: string
   modelType?: "foundational" | "fine-tuned" | "na"
@@ -42,6 +41,7 @@ export type EvaluationData = {
   selectedCategories: string[]
   excludedCategoryReasons?: Record<string, string>
   categoryScores: Record<string, CategoryScore>
+  categoryEvaluationsDetailed?: Record<string, any>
   currentCategory: string | null
 }
 
@@ -103,7 +103,7 @@ export function AIEvaluationDashboard({ onBack, onSaveEvaluation }: AIEvaluation
       console.log("[v0] Updated categoryScores:", newCategoryScores)
       return {
         ...prev,
-        categoryScores: newCategoryScores,
+  categoryScores: newCategoryScores,
       }
     })
 
@@ -126,6 +126,17 @@ export function AIEvaluationDashboard({ onBack, onSaveEvaluation }: AIEvaluation
     }
   }
 
+  const handleSaveDetailed = (categoryId: string, data: any) => {
+    console.log('[v0] handleSaveDetailed called for', categoryId, data)
+    setEvaluationData((prev) => ({
+      ...prev,
+      categoryEvaluationsDetailed: {
+        ...(prev.categoryEvaluationsDetailed || {}),
+        [categoryId]: data,
+      },
+    }))
+  }
+
   const handleSaveEvaluation = async () => {
     console.log("[v0] handleSaveEvaluation called")
     console.log("[v0] evaluationData:", evaluationData)
@@ -142,14 +153,14 @@ export function AIEvaluationDashboard({ onBack, onSaveEvaluation }: AIEvaluation
     console.log("[v0] Processing category scores:", evaluationData.categoryScores)
 
     const capabilityCategories = evaluationData.selectedCategories.filter((cat) => {
-      const category = CATEGORIES.find((c) => c.id === cat)
+      const category = getCategoryById(cat)
       console.log("[v0] Category check:", cat, "type:", category?.type)
       return category?.type === "capability"
     })
     console.log("[v0] Capability categories:", capabilityCategories)
 
     const riskCategories = evaluationData.selectedCategories.filter((cat) => {
-      const category = CATEGORIES.find((c) => c.id === cat)
+      const category = getCategoryById(cat)
       return category?.type === "risk"
     })
     console.log("[v0] Risk categories:", riskCategories)
@@ -184,11 +195,12 @@ export function AIEvaluationDashboard({ onBack, onSaveEvaluation }: AIEvaluation
       version: evaluationData.systemInfo.url || "1.0",
       deploymentContext: evaluationData.systemInfo.deploymentContexts.join(", ") || "Production",
       evaluator: "Current User",
-      modality: evaluationData.systemInfo.modality,
+      inputModalities: evaluationData.systemInfo.inputModalities || ["Text"],
+      outputModalities: evaluationData.systemInfo.outputModalities || ["Text"],
       evaluationDate: new Date().toISOString().split("T")[0],
       selectedCategories: evaluationData.selectedCategories,
   excludedCategoryReasons: evaluationData.excludedCategoryReasons || {},
-      categoryEvaluations: evaluationData.categoryScores,
+  categoryEvaluations: evaluationData.categoryEvaluationsDetailed || evaluationData.categoryScores,
       overallStats: {
         completenessScore: 85, // Safe default value
         totalApplicable: evaluationData.selectedCategories.length,
@@ -233,7 +245,7 @@ export function AIEvaluationDashboard({ onBack, onSaveEvaluation }: AIEvaluation
       case "categories":
         return (
           <CategorySelection
-            categories={CATEGORIES}
+            categories={getAllCategories()}
             selectedCategories={evaluationData.selectedCategories}
             onSelectionChange={handleCategoriesSelectedWithReasons}
           />
@@ -241,10 +253,11 @@ export function AIEvaluationDashboard({ onBack, onSaveEvaluation }: AIEvaluation
       case "evaluation":
         return (
           <EvaluationForm
-            categories={CATEGORIES}
+            categories={getAllCategories()}
             selectedCategories={evaluationData.selectedCategories}
             categoryScores={evaluationData.categoryScores}
             onScoreUpdate={(categoryId, score) => handleCategoryComplete(categoryId, score)}
+            onSaveDetailed={(catId, data) => handleSaveDetailed(catId, data)}
             onComplete={() => setCurrentStep("results")}
           />
         )
@@ -252,7 +265,7 @@ export function AIEvaluationDashboard({ onBack, onSaveEvaluation }: AIEvaluation
         return (
           <ResultsDashboard
             systemInfo={evaluationData.systemInfo}
-            categories={CATEGORIES}
+            categories={getAllCategories()}
             selectedCategories={evaluationData.selectedCategories}
             categoryScores={evaluationData.categoryScores}
             excludedCategoryReasons={evaluationData.excludedCategoryReasons || {}}

components/category-evaluation.tsx

@@ -12,151 +12,15 @@ import { Separator } from "@/components/ui/separator"
 import type { CategoryScore } from "@/components/ai-evaluation-dashboard"
 import { HelpCircle, CheckCircle, Plus, Trash2 } from "lucide-react"
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip"
-import { BENCHMARK_QUESTIONS, PROCESS_QUESTIONS, SOURCE_TYPES, ADDITIONAL_ASPECTS_SECTION, getFieldPlaceholder, getHint } from "@/lib/category-data"
+import { SOURCE_TYPES, ADDITIONAL_ASPECTS_SECTION, getFieldPlaceholder, getHint } from "@/lib/schema"
+import { getBenchmarkQuestions, getProcessQuestions } from '@/lib/schema'
+import formSchema from '@/schema/evaluation-schema.json'
 
 // The detailed per-category and per-question hints, plus recommended placeholders,
 // are centralized in `lib/category-data.ts`. This component uses the exported
 // helpers `getHint` and `getFieldPlaceholder` and the question lists.
 
-const CustomFieldComponent = ({
-  questionId,
-  fieldType,
-  value,
-  onChange,
-}: {
-  questionId: string
-  fieldType: string
-  value: string
-  onChange: (value: string) => void
-}) => {
-  const getFieldConfig = (questionId: string, fieldType: string) => {
-    const configs: Record<string, Record<string, { label: string; placeholder: string; type?: string }>> = {
-      A2: {
-        thresholds: { label: "Quantitative Thresholds", placeholder: "e.g., >85% accuracy, <0.1 error rate" },
-        thresholdSource: {
-          label: "Threshold Source",
-          placeholder: "e.g., industry standard, research paper, policy requirement",
-        },
-        passFail: { label: "Pass/Fail Determination", placeholder: "e.g., Pass - exceeded 85% threshold" },
-      },
-      A3: {
-        comparativeScores: {
-          label: "Comparative Scores",
-          placeholder: "e.g., Our model: 87.2%, GPT-4: 85.1%, Previous version: 82.3%",
-        },
-        baselineType: { label: "Baseline Type", placeholder: "e.g., SOTA, previous version, industry standard" },
-        significance: { label: "Statistical Significance", placeholder: "e.g., p<0.05, 95% CI: [1.2, 3.8]" },
-      },
-      A4: {
-        testTypes: { label: "Test Types", placeholder: "e.g., adversarial attacks, load testing, distribution shift" },
-        failureRates: { label: "Failure/Degradation Rates", placeholder: "e.g., 15% failure under adversarial inputs" },
-        robustnessMetrics: {
-          label: "Robustness Metrics",
-          placeholder: "e.g., attack success rate, performance drop %",
-        },
-      },
-      A5: {
-        liveMetrics: { label: "Live Metrics Tracked", placeholder: "e.g., error rates, latency, drift detection" },
-        samplingCadence: { label: "Sampling Cadence", placeholder: "e.g., every 1000 requests, hourly, daily" },
-        alertThresholds: { label: "Alert Thresholds", placeholder: "e.g., >5% error rate, >500ms latency" },
-      },
-      A6: {
-        procedure: {
-          label: "Contamination Check Procedure",
-          placeholder: "e.g., n-gram overlap analysis, URL deduplication",
-        },
-        contaminationRate: {
-          label: "Contamination Rate",
-          placeholder: "e.g., <1% overlap detected, 0.3% exact matches",
-        },
-        mitigations: { label: "Mitigations Taken", placeholder: "e.g., removed overlapping samples, used holdout set" },
-      },
-      A7: {
-        comparisonSystems: { label: "Comparison Systems", placeholder: "e.g., GPT-4, Claude-3, Gemini Pro" },
-        evaluationConditions: {
-          label: "Evaluation Conditions",
-          placeholder: "e.g., same prompts, temperature=0, identical hardware",
-        },
-        relativeMetrics: {
-          label: "Relative Performance Metrics",
-          placeholder: "e.g., 15% better accuracy, 2x faster inference",
-        },
-      },
-      B1: {
-        scope: {
-          label: "Evaluation Scope",
-          placeholder: "e.g., measures reasoning capability in mathematical contexts",
-        },
-        successFailureDefinitions: {
-          label: "Success/Failure Definitions",
-          placeholder: "e.g., success = >80% on grade-level problems",
-        },
-        hypotheses: { label: "Hypotheses Being Tested", placeholder: "e.g., model can solve multi-step word problems" },
-      },
-      B2: {
-        replicationPackage: {
-          label: "Replication Package",
-          placeholder: "e.g., GitHub repo with code, configs, prompts",
-        },
-        accessLevel: { label: "Access Level", placeholder: "e.g., public, access-controlled, internal only" },
-        proxies: { label: "Proxies (if not shareable)", placeholder: "e.g., synthetic examples, anonymized data" },
-      },
-      B5: {
-        reviewers: { label: "Reviewers", placeholder: "e.g., domain experts, affected user groups, ethics board" },
-        feedbackChanges: {
-          label: "Changes from Feedback",
-          placeholder: "e.g., added bias metrics, revised interpretation",
-        },
-        disagreements: {
-          label: "Unresolved Disagreements",
-          placeholder: "e.g., threshold levels, risk severity ratings",
-        },
-      },
-      B6: {
-        uncertaintyDisclosure: {
-          label: "Uncertainty Disclosure",
-          placeholder: "e.g., error bars, confidence intervals, variance across runs",
-        },
-        axesConsistency: { label: "Axes Consistency", placeholder: "e.g., consistent 0-100 scale, no truncated axes" },
-        sampleSizes: { label: "Sample Sizes", placeholder: "e.g., n=1000 test samples, 5 random seeds" },
-        selectionCriteria: { label: "Selection Criteria", placeholder: "e.g., all results shown, no cherry-picking" },
-      },
-      B8: {
-        triggers: {
-          label: "Re-evaluation Triggers",
-          placeholder: "e.g., model updates, data drift >5%, security incidents",
-        },
-        versionedSpecs: { label: "Versioned Eval Specs", placeholder: "e.g., eval spec v2.1, change log maintained" },
-        auditTrail: { label: "Audit Trail", placeholder: "e.g., all changes logged with timestamps and rationale" },
-        mitigationProtocols: {
-          label: "Mitigation Protocols",
-          placeholder: "e.g., automated rollback, manual review process",
-        },
-        retestProcedures: {
-          label: "Retest Procedures",
-          placeholder: "e.g., full eval suite after fixes, regression testing",
-        },
-      },
-    }
-
-    return configs[questionId]?.[fieldType] || { label: fieldType, placeholder: "" }
-  }
-
-  const config = getFieldConfig(questionId, fieldType)
-
-  return (
-    <div>
-      <Label className="text-xs font-medium">{config.label}</Label>
-      <Textarea
-        placeholder={config.placeholder}
-        value={value}
-        onChange={(e) => onChange(e.target.value)}
-        rows={2}
-        className="mt-1"
-      />
-    </div>
-  )
-}
+// All benchmark questions share the same input fields; all process questions share the same input fields.
 
 // Local types used by this component (kept minimal for readability)
 export type Source = {
@@ -190,9 +54,10 @@ export type CategoryEvaluationProps = {
   category: { id: string; name: string; description: string; type: string; detailedGuidance?: string }
   score?: CategoryScore | null
   onScoreUpdate: (score: CategoryScore) => void
+  onSaveDetailed?: (categoryId: string, data: any) => void
 }
 
-export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryEvaluationProps) {
+export function CategoryEvaluation({ category, score, onScoreUpdate, onSaveDetailed }: CategoryEvaluationProps) {
   const [benchmarkAnswers, setBenchmarkAnswers] = useState<Record<string, string>>({})
   const [processAnswers, setProcessAnswers] = useState<Record<string, string>>({})
   const [benchmarkSources, setBenchmarkSources] = useState<Record<string, Source[]>>({})
@@ -209,8 +74,11 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
 
   const addSource = (questionId: string, section: "benchmark" | "process") => {
     if (section === "benchmark") {
+      const newId = (globalThis.crypto && (globalThis.crypto as any).randomUUID)
+        ? (globalThis.crypto as any).randomUUID()
+        : Date.now().toString()
       const newSource: Source = {
-        id: Date.now().toString(),
+        id: newId,
         url: "",
         description: "",
         sourceType: "internal",
@@ -227,8 +95,11 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
         [questionId]: [...(prev[questionId] || []), newSource],
       }))
     } else {
+      const newId = (globalThis.crypto && (globalThis.crypto as any).randomUUID)
+        ? (globalThis.crypto as any).randomUUID()
+        : Date.now().toString()
       const newDocSource: DocumentationSource = {
-        id: Date.now().toString(),
+        id: newId,
         url: "",
         description: "",
         sourceType: "internal",
@@ -326,8 +197,8 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
 
   const currentScore = useMemo(() => {
     // Calculate counts
-    const totalBenchmarkQuestions = BENCHMARK_QUESTIONS.length
-    const totalProcessQuestions = PROCESS_QUESTIONS.length
+  const totalBenchmarkQuestions = getBenchmarkQuestions().length
+  const totalProcessQuestions = getProcessQuestions().length
     const totalQuestions = totalBenchmarkQuestions + totalProcessQuestions
 
     const benchmarkYesCount = Object.values(benchmarkAnswers).filter((answer) => answer === "yes").length
@@ -410,12 +281,22 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
     }
 
     console.log("[v0] Saving category evaluation")
+    const detailed = {
+      benchmarkAnswers,
+      processAnswers,
+      benchmarkSources,
+      processSources,
+      additionalAspects,
+      score: currentScore,
+    }
+    console.log("[v0] Calling onSaveDetailed with:", detailed)
+    onSaveDetailed?.(category.id, detailed)
     console.log("[v0] Calling onScoreUpdate with:", currentScore)
     onScoreUpdate(currentScore)
   }
 
   const isComplete =
-    Object.keys(benchmarkAnswers).length + Object.keys(processAnswers).length === BENCHMARK_QUESTIONS.length + PROCESS_QUESTIONS.length
+    Object.keys(benchmarkAnswers).length + Object.keys(processAnswers).length === getBenchmarkQuestions().length + getProcessQuestions().length
 
   return (
     <TooltipProvider>
@@ -485,7 +366,7 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
             </CardDescription>
           </CardHeader>
           <CardContent className="space-y-6">
-            {BENCHMARK_QUESTIONS.map((question) => (
+            {getBenchmarkQuestions().map((question) => (
               <div key={question.id} className="space-y-3">
                 <div className="flex items-start gap-2">
                   <Label className="text-sm font-medium flex-1">
@@ -568,114 +449,45 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
                         <div className="grid gap-3">
                           {/* no structured hint here; description has contextual hints */}
 
-                          <div>
-                            <Label className="text-xs">Benchmark/Dataset Name</Label>
-                            <Input
-                              placeholder={getFieldPlaceholder(category.id, question.id, "benchmarkName")}
-                              value={source.benchmarkName || ""}
-                              onChange={(e) =>
-                                updateSource(question.id, source.id, "benchmarkName", e.target.value, "benchmark")
-                              }
-                            />
-                          </div>
-
-                          <div className="grid grid-cols-2 gap-3">
-                            <div>
-                              <Label className="text-xs">Version</Label>
-                              <Input
-                                placeholder="e.g., v1.2, 2024-01"
-                                value={source.version || ""}
-                                onChange={(e) =>
-                                  updateSource(question.id, source.id, "version", e.target.value, "benchmark")
-                                }
-                              />
-                            </div>
-                            <div>
-                              <Label className="text-xs">Task Variants</Label>
-                              <Input
-                                placeholder="e.g., multiple choice, generation"
-                                value={source.taskVariants || ""}
-                                onChange={(e) =>
-                                  updateSource(question.id, source.id, "taskVariants", e.target.value, "benchmark")
-                                }
-                              />
-                            </div>
-                          </div>
-
-                          <div>
-                            <Label className="text-xs">Metrics</Label>
-                            <Input
-                              placeholder={getFieldPlaceholder(category.id, question.id, "metrics")}
-                              value={source.metrics || ""}
-                              onChange={(e) =>
-                                updateSource(question.id, source.id, "metrics", e.target.value, "benchmark")
-                              }
-                            />
-                          </div>
-
-                          <div>
-                            <Label className="text-xs">URL</Label>
-                            <Input
-                              placeholder="https://..."
-                              value={source.url}
-                              onChange={(e) => updateSource(question.id, source.id, "url", e.target.value, "benchmark")}
-                            />
-                          </div>
-
-                          <div>
-                            <Label className="text-xs">Description</Label>
-                            <Textarea
-                              placeholder="Describe the benchmark, test, or evaluation method..."
-                              value={source.description}
-                              onChange={(e) =>
-                                updateSource(question.id, source.id, "description", e.target.value, "benchmark")
-                              }
-                              rows={2}
-                            />
-                            <p className="text-xs text-muted-foreground mt-1">
-                              {getHint(category.id, question.id, "benchmark")}
-                            </p>
-                          </div>
-
-                          <div className="grid grid-cols-2 gap-3">
-                            <div>
-                              <Label className="text-xs">Source Type</Label>
-                              <RadioGroup
-                                value={source.sourceType}
-                                onValueChange={(value) =>
-                                  updateSource(question.id, source.id, "sourceType", value, "benchmark")
-                                }
-                              >
-                                {Object.entries(SOURCE_TYPES).map(([key, type]) => (
-                                  <div key={key} className="flex items-center space-x-2">
-                                    <RadioGroupItem value={key} id={`${source.id}-${key}`} />
-                                    <Label htmlFor={`${source.id}-${key}`} className="text-xs">
-                                      {type.label}
-                                    </Label>
+                          {/* Render benchmark source fields from form-schema.json to keep fields uniform */}
+                          {formSchema.benchmarkSourceFields.map((field: any) => (
+                            <div key={field.name}>
+                              <Label className="text-xs">{field.label}</Label>
+                              {field.type === "textarea" ? (
+                                <Textarea
+                                  placeholder={field.placeholder || ""}
+                                  value={(source as any)[field.name] || ""}
+                                  onChange={(e) => updateSource(question.id, source.id, field.name, e.target.value, "benchmark")}
+                                  rows={field.rows || 2}
+                                />
+                              ) : field.type === "radio" ? (
+                                <RadioGroup
+                                  value={(source as any)[field.name] || "internal"}
+                                  onValueChange={(value) => updateSource(question.id, source.id, field.name, value, "benchmark")}
+                                >
+                                  <div className="flex flex-col gap-2">
+                                    {field.options.map((opt: any) => (
+                                      <div key={opt.value} className="flex items-center space-x-2">
+                                        <RadioGroupItem value={opt.value} id={`${source.id}-${field.name}-${opt.value}`} />
+                                        <Label htmlFor={`${source.id}-${field.name}-${opt.value}`} className="text-xs">
+                                          {opt.label}
+                                        </Label>
+                                      </div>
+                                    ))}
                                   </div>
-                                ))}
-                              </RadioGroup>
-                            </div>
-
-                            <div>
-                              <Label className="text-xs">Score (if applicable)</Label>
-                              <Input
-                                placeholder="e.g., 85%, 0.92, Pass"
-                                value={source.score || ""}
-                                onChange={(e) =>
-                                  updateSource(question.id, source.id, "score", e.target.value, "benchmark")
-                                }
-                              />
-                              <Label className="text-xs mt-2">Confidence Interval (optional)</Label>
-                              <Input
-                                placeholder="e.g., 95% CI [90,94]"
-                                value={(source as any).confidenceInterval || ""}
-                                onChange={(e) =>
-                                  updateSource(question.id, source.id, "confidenceInterval", e.target.value, "benchmark")
-                                }
-                              />
+                                </RadioGroup>
+                              ) : (
+                                <Input
+                                  placeholder={field.placeholder || ""}
+                                  value={(source as any)[field.name] || ""}
+                                  onChange={(e) => updateSource(question.id, source.id, field.name, e.target.value, "benchmark")}
+                                />
+                              )}
+                              {field.name === "description" && (
+                                <p className="text-xs text-muted-foreground mt-1">{getHint(category.id, question.id, "benchmark")}</p>
+                              )}
                             </div>
-                          </div>
+                          ))}
                         </div>
                       </div>
                     ))}
@@ -702,7 +514,7 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
             </CardDescription>
           </CardHeader>
           <CardContent className="space-y-6">
-            {PROCESS_QUESTIONS.map((question) => (
+            {getProcessQuestions().map((question) => (
               <div key={question.id} className="space-y-3">
                 <div className="flex items-start gap-2">
                   <Label className="text-sm font-medium flex-1">
@@ -785,99 +597,29 @@ export function CategoryEvaluation({ category, score, onScoreUpdate }: CategoryE
                         <div className="grid gap-3">
                           {/* no structured hint here; description has contextual hints */}
 
-                          <div>
-                            <Label className="text-xs">URL</Label>
-                            <Input
-                              placeholder="https://..."
-                              value={source.url}
-                              onChange={(e) => updateSource(question.id, source.id, "url", e.target.value, "process")}
-                            />
-                          </div>
-
-                          <div>
-                            <Label className="text-xs">Description</Label>
-                            <Textarea
-                              placeholder="Describe the documentation, policy, or process..."
-                              value={source.description}
-                              onChange={(e) =>
-                                updateSource(question.id, source.id, "description", e.target.value, "process")
-                              }
-                              rows={2}
-                            />
-                            <p className="text-xs text-muted-foreground mt-1">
-                              {getHint(category.id, question.id, "process")}
-                            </p>
-                          </div>
-
-                          <div className="grid grid-cols-2 gap-3">
-                            <div>
-                              <Label className="text-xs">Source Type</Label>
-                              <RadioGroup
-                                value={source.sourceType}
-                                onValueChange={(value) =>
-                                  updateSource(question.id, source.id, "sourceType", value, "process")
-                                }
-                              >
-                                {Object.entries(SOURCE_TYPES).map(([key, type]) => (
-                                  <div key={key} className="flex items-center space-x-2">
-                                    <RadioGroupItem value={key} id={`${source.id}-${key}`} />
-                                    <Label htmlFor={`${source.id}-${key}`} className="text-xs">
-                                      {type.label}
-                                    </Label>
-                                  </div>
-                                ))}
-                              </RadioGroup>
-                            </div>
-
-                            <div>
-                              <Label className="text-xs">Document Type</Label>
-                              <Input
-                                placeholder="e.g., Policy, Procedure, Report"
-                                value={source.documentType || ""}
-                                onChange={(e) =>
-                                  updateSource(question.id, source.id, "documentType", e.target.value, "process")
-                                }
-                              />
-                            </div>
-                          </div>
-
-                          <div className="grid grid-cols-2 gap-3 mt-2">
-                            <div>
-                              <Label className="text-xs">Title</Label>
-                              <Input
-                                placeholder="Document title"
-                                value={(source as any).title || ""}
-                                onChange={(e) => updateSource(question.id, source.id, "title", e.target.value, "process")}
-                              />
-                            </div>
-                            <div>
-                              <Label className="text-xs">Author</Label>
-                              <Input
-                                placeholder="Author or owner"
-                                value={(source as any).author || ""}
-                                onChange={(e) => updateSource(question.id, source.id, "author", e.target.value, "process")}
-                              />
-                            </div>
-                          </div>
-
-                          <div className="grid grid-cols-2 gap-3 mt-2">
-                            <div>
-                              <Label className="text-xs">Organization</Label>
-                              <Input
-                                placeholder="Owning org"
-                                value={(source as any).organization || ""}
-                                onChange={(e) => updateSource(question.id, source.id, "organization", e.target.value, "process")}
-                              />
-                            </div>
-                            <div>
-                              <Label className="text-xs">Date</Label>
-                              <Input
-                                placeholder="YYYY-MM-DD"
-                                value={(source as any).date || ""}
-                                onChange={(e) => updateSource(question.id, source.id, "date", e.target.value, "process")}
-                              />
+                          {/* Render process source fields from form-schema.json */}
+                          {formSchema.processSourceFields.map((field: any) => (
+                            <div key={field.name}>
+                              <Label className="text-xs">{field.label}</Label>
+                              {field.type === "textarea" ? (
+                                <Textarea
+                                  placeholder={field.placeholder || ""}
+                                  value={(source as any)[field.name] || ""}
+                                  onChange={(e) => updateSource(question.id, source.id, field.name, e.target.value, "process")}
+                                  rows={field.rows || 2}
+                                />
+                              ) : (
+                                <Input
+                                  placeholder={field.placeholder || ""}
+                                  value={(source as any)[field.name] || ""}
+                                  onChange={(e) => updateSource(question.id, source.id, field.name, e.target.value, "process")}
+                                />
+                              )}
+                              {field.name === "description" && (
+                                <p className="text-xs text-muted-foreground mt-1">{getHint(category.id, question.id, "process")}</p>
+                              )}
                             </div>
-                          </div>
+                          ))}
 
                           
                         </div>

components/evaluation-card.tsx

@@ -13,7 +13,8 @@ export type EvaluationCardData = {
   id: string
   systemName: string
   provider: string
-  modality: string // Added modality field
+  inputModalities: string[]
+  outputModalities: string[]
   completedDate: string
   applicableCategories: number
   completedCategories: number
@@ -68,13 +69,42 @@ export function EvaluationCard({ evaluation, onView, onDelete }: EvaluationCardP
   const toggleArea = (area: string) => setExpandedAreas((p) => ({ ...p, [area]: !p[area] }))
   const router = useRouter()
   const modalityMap: Record<string, { label: string; emoji?: string; variant?: string }> = {
-    "text-to-text": { label: "Text → Text", emoji: "📝" },
-    "text-to-image": { label: "Text → Image", emoji: "🖼️" },
-    multimodal: { label: "Multimodal", emoji: "🤖" },
-    "speech-to-text": { label: "Speech → Text", emoji: "🗣️" },
-    "speech-to-speech": { label: "Speech → Speech", emoji: "🔊" },
-    "image-to-text": { label: "Image → Text", emoji: "📷" },
-    code: { label: "Code", emoji: "💻" },
+    "Text": { label: "Text", emoji: "📝" },
+    "Image": { label: "Image", emoji: "🖼️" },
+    "Audio": { label: "Audio", emoji: "🔊" },
+    "Video": { label: "Video", emoji: "🎥" },
+    "Tabular": { label: "Tabular", emoji: "📊" },
+    "Robotics/Action": { label: "Robotics", emoji: "🤖" },
+    "Other": { label: "Other", emoji: "⚡" },
+  }
+
+  const getModalityDisplay = (inputModalities: string[], outputModalities: string[]) => {
+    const inputStr = inputModalities.join(", ")
+    const outputStr = outputModalities.join(", ")
+    
+    // Special cases for common patterns
+    if (inputModalities.length === 1 && outputModalities.length === 1) {
+      if (inputModalities[0] === "Text" && outputModalities[0] === "Text") {
+        return { label: "Text → Text", emoji: "�" }
+      }
+      if (inputModalities[0] === "Text" && outputModalities[0] === "Image") {
+        return { label: "Text → Image", emoji: "�️" }
+      }
+      if (inputModalities[0] === "Image" && outputModalities[0] === "Text") {
+        return { label: "Image → Text", emoji: "📷" }
+      }
+      if (inputModalities[0] === "Tabular" && outputModalities[0] === "Tabular") {
+        return { label: "Tabular", emoji: "📊" }
+      }
+    }
+    
+    // Multimodal cases
+    if (inputModalities.length > 1 || outputModalities.length > 1) {
+      return { label: "Multimodal", emoji: "🤖" }
+    }
+    
+    // Fallback
+    return { label: `${inputStr} → ${outputStr}`, emoji: "⚡" }
   }
   const getUniqueCount = (lists: string[][]) => {
     const set = new Set<string>()
@@ -147,14 +177,24 @@ export function EvaluationCard({ evaluation, onView, onDelete }: EvaluationCardP
             <div className="space-y-1 flex-1 min-w-0">
               <CardTitle className="text-lg font-heading truncate">{evaluation.systemName}</CardTitle>
               <p className="text-sm text-muted-foreground truncate">{evaluation.provider}</p>
-              {/* Pretty modality badge with emoji */}
+              {/* Enhanced modality badge with emoji and hover detail */}
               {(() => {
-                const info = modalityMap[evaluation.modality] || { label: evaluation.modality }
+                const info = getModalityDisplay(evaluation.inputModalities, evaluation.outputModalities)
                 return (
-                  <Badge variant={info.variant as any || "secondary"} className="text-xs px-2 py-1 w-fit flex items-center gap-2">
-                    {info.emoji ? <span aria-hidden>{info.emoji}</span> : null}
-                    <span className="whitespace-nowrap">{info.label}</span>
-                  </Badge>
+                  <Tooltip>
+                    <TooltipTrigger asChild>
+                      <Badge variant="secondary" className="text-xs px-2 py-1 w-fit flex items-center gap-2 cursor-help">
+                        {info.emoji ? <span aria-hidden className="text-sm">{info.emoji}</span> : null}
+                        <span className="whitespace-nowrap">{info.label}</span>
+                      </Badge>
+                    </TooltipTrigger>
+                    <TooltipContent side="bottom" className="max-w-xs">
+                      <div className="text-sm">
+                        <div><strong>Input:</strong> {evaluation.inputModalities.join(", ")}</div>
+                        <div><strong>Output:</strong> {evaluation.outputModalities.join(", ")}</div>
+                      </div>
+                    </TooltipContent>
+                  </Tooltip>
                 )
               })()}
             </div>

components/evaluation-form.tsx

@@ -15,7 +15,7 @@ interface Category {
   name: string
   type: "capability" | "risk"
   description: string
-  detailedGuidance: string
+  detailedGuidance?: string
 }
 
 interface EvaluationFormProps {
@@ -23,6 +23,7 @@ interface EvaluationFormProps {
   selectedCategories: string[]
   categoryScores: Record<string, CategoryScore>
   onScoreUpdate: (categoryId: string, score: CategoryScore) => void
+  onSaveDetailed?: (categoryId: string, data: any) => void
   onComplete: () => void
 }
 
@@ -31,6 +32,7 @@ export function EvaluationForm({
   selectedCategories,
   categoryScores,
   onScoreUpdate,
+  onSaveDetailed,
   onComplete,
 }: EvaluationFormProps) {
   const [currentCategoryIndex, setCurrentCategoryIndex] = useState(0)
@@ -150,6 +152,7 @@ export function EvaluationForm({
               category={currentCategory}
               score={categoryScores[currentCategory.id]}
               onScoreUpdate={(score) => onScoreUpdate(currentCategory.id, score)}
+              onSaveDetailed={(catId, data) => onSaveDetailed?.(catId, data)}
             />
           )}
 

components/system-info-form.tsx

@@ -10,45 +10,27 @@ import { Label } from "@/components/ui/label"
 import { Checkbox } from "@/components/ui/checkbox"
 import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"
 import type { SystemInfo } from "@/components/ai-evaluation-dashboard"
+import { getSystemInfoFormOptions } from "@/lib/schema"
 
 interface SystemInfoFormProps {
   onSubmit: (data: SystemInfo) => void
   initialData: SystemInfo | null
 }
 
-const SYSTEM_TYPES = [
-  "Text-to-Text (e.g., chatbots, language models)",
-  "Text-to-Image (e.g., image generation)",
-  "Image-to-Text (e.g., image captioning, OCR)",
-  "Image-to-Image (e.g., image editing, style transfer)",
-  "Audio/Speech (e.g., speech recognition, text-to-speech)",
-  "Video (e.g., video generation, analysis)",
-  "Multimodal",
-  "Robotic/Embodied AI",
-  "Other",
-]
-
-const DEPLOYMENT_CONTEXTS = [
-  "Research/Academic",
-  "Internal/Enterprise Use",
-  "Public/Consumer-Facing",
-  "High-Risk Applications",
-  "Other",
-]
+const formOptions = getSystemInfoFormOptions()
 
 export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
   const [formData, setFormData] = useState<SystemInfo>({
     name: initialData?.name || "",
     url: initialData?.url || "",
     provider: initialData?.provider || "",
-    systemTypes: initialData?.systemTypes || [],
-  deploymentContexts: initialData?.deploymentContexts || [],
-  modality: initialData?.modality || "text",
-  modelTag: (initialData as any)?.modelTag || "",
-  knowledgeCutoff: (initialData as any)?.knowledgeCutoff || "",
-  modelType: (initialData as any)?.modelType || "na",
-  inputModalities: (initialData as any)?.inputModalities || [],
-  outputModalities: (initialData as any)?.outputModalities || [],
+    version: initialData?.version || "",
+    deploymentContexts: initialData?.deploymentContexts || [],
+    modelTag: initialData?.modelTag || "",
+    knowledgeCutoff: initialData?.knowledgeCutoff || "",
+    modelType: initialData?.modelType || "na",
+    inputModalities: initialData?.inputModalities || [],
+    outputModalities: initialData?.outputModalities || [],
   })
 
   const handleSubmit = (e: React.FormEvent) => {
@@ -56,13 +38,6 @@ export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
     onSubmit(formData)
   }
 
-  const handleSystemTypeChange = (type: string, checked: boolean) => {
-    setFormData((prev: SystemInfo) => ({
-      ...prev,
-      systemTypes: checked ? [...prev.systemTypes, type] : prev.systemTypes.filter((t) => t !== type),
-    }))
-  }
-
   const handleDeploymentContextChange = (context: string, checked: boolean) => {
     setFormData((prev: SystemInfo) => ({
       ...prev,
@@ -113,6 +88,18 @@ export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
                 placeholder="e.g., gpt-4-1-2025-04-14"
               />
             </div>
+            <div className="space-y-2">
+              <Label htmlFor="version">System Version</Label>
+              <Input
+                id="version"
+                value={formData.version}
+                onChange={(e) => setFormData((prev) => ({ ...prev, version: e.target.value }))}
+                placeholder="e.g., v3.2.1"
+              />
+            </div>
+          </div>
+
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
             <div className="space-y-2">
               <Label htmlFor="knowledgeCutoff">Knowledge Cutoff Date</Label>
               <Input
@@ -122,17 +109,16 @@ export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
                 placeholder="YYYY-MM-DD"
               />
             </div>
-          </div>
-
-          <div className="space-y-2">
-            <Label htmlFor="provider">Provider/Organization *</Label>
-            <Input
-              id="provider"
-              value={formData.provider}
-              onChange={(e) => setFormData((prev) => ({ ...prev, provider: e.target.value }))}
-              placeholder="e.g., OpenAI, Anthropic, Internal Team"
-              required
-            />
+            <div className="space-y-2">
+              <Label htmlFor="provider">Provider/Organization *</Label>
+              <Input
+                id="provider"
+                value={formData.provider}
+                onChange={(e) => setFormData((prev) => ({ ...prev, provider: e.target.value }))}
+                placeholder="e.g., OpenAI, Anthropic, Internal Team"
+                required
+              />
+            </div>
           </div>
 
           <div className="space-y-4">
@@ -141,18 +127,12 @@ export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
               <div className="mt-3">
                 <RadioGroup value={formData.modelType} onValueChange={(val) => setFormData((prev) => ({ ...prev, modelType: val as any }))}>
                   <div className="flex items-center gap-4">
-                    <div className="flex items-center gap-2">
-                      <RadioGroupItem value="foundational" id="mt-foundational" />
-                      <Label htmlFor="mt-foundational" className="text-sm">Foundational Model</Label>
-                    </div>
-                    <div className="flex items-center gap-2">
-                      <RadioGroupItem value="fine-tuned" id="mt-finetuned" />
-                      <Label htmlFor="mt-finetuned" className="text-sm">Fine-tuned Model</Label>
-                    </div>
-                    <div className="flex items-center gap-2">
-                      <RadioGroupItem value="na" id="mt-na" />
-                      <Label htmlFor="mt-na" className="text-sm">Doesn't apply</Label>
-                    </div>
+                    {formOptions.modelTypes.map((type) => (
+                      <div key={type.value} className="flex items-center gap-2">
+                        <RadioGroupItem value={type.value} id={`mt-${type.value}`} />
+                        <Label htmlFor={`mt-${type.value}`} className="text-sm">{type.label}</Label>
+                      </div>
+                    ))}
                   </div>
                 </RadioGroup>
               </div>
@@ -161,7 +141,7 @@ export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
             <div>
               <Label className="text-base font-medium">Input modalities (select all that apply) *</Label>
               <div className="grid grid-cols-1 md:grid-cols-2 gap-3 mt-3">
-                {['Text','Image','Audio','Video','Tabular','Robotics/Action','Other'].map((m) => (
+                {formOptions.modalities.map((m) => (
                   <div key={m} className="flex items-center gap-2">
                     <Checkbox
                       id={`in-${m}`}
@@ -186,7 +166,7 @@ export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
             <div>
               <Label className="text-base font-medium">Output modalities (select all that apply) *</Label>
               <div className="grid grid-cols-1 md:grid-cols-2 gap-3 mt-3">
-                {['Text','Image','Audio','Video','Tabular','Robotics/Action','Other'].map((m) => (
+                {formOptions.modalities.map((m) => (
                   <div key={m} className="flex items-center gap-2">
                     <Checkbox
                       id={`out-${m}`}
@@ -211,7 +191,7 @@ export function SystemInfoForm({ onSubmit, initialData }: SystemInfoFormProps) {
             <div>
               <Label className="text-base font-medium">Deployment Context (select all that apply) *</Label>
               <div className="grid grid-cols-1 md:grid-cols-2 gap-3 mt-3">
-                {DEPLOYMENT_CONTEXTS.map((context) => (
+                {formOptions.deploymentContexts.map((context) => (
                   <div key={context} className="flex items-center space-x-2">
                     <Checkbox
                       id={`context-${context}`}

data/evaluations/claude-3-sonnet.json

@@ -1,58 +0,0 @@
-{
-  "id": "2",
-  "systemName": "Claude 3.5 Sonnet",
-  "provider": "Anthropic",
-  "modality": "Text-to-Text",
-  "version": "claude-3-5-sonnet-20241022",
-  "deploymentContext": "API Service",
-  "evaluationDate": "2024-12-10",
-  "evaluator": "Anthropic Safety Team",
-  "selectedCategories": [
-    "language-communication",
-    "social-intelligence",
-    "problem-solving",
-    "creativity-innovation",
-    "learning-memory",
-    "perception-vision",
-    "metacognition",
-    "harmful-content",
-    "information-integrity",
-    "privacy-data",
-    "bias-fairness",
-    "security-robustness",
-    "dangerous-capabilities",
-    "human-ai-interaction",
-    "environmental-impact",
-    "economic-displacement",
-    "governance-accountability",
-    "value-chain"
-  ],
-  "overallStats": {
-    "totalApplicable": 18,
-    "capabilityApplicable": 7,
-    "riskApplicable": 11,
-    "strongCategories": [
-      "language-communication",
-      "social-intelligence",
-      "harmful-content",
-      "information-integrity",
-      "privacy-data",
-      "bias-fairness",
-      "security-robustness",
-      "human-ai-interaction"
-    ],
-    "adequateCategories": [
-      "problem-solving",
-      "creativity-innovation",
-      "learning-memory",
-      "perception-vision",
-      "metacognition",
-      "dangerous-capabilities",
-      "governance-accountability",
-      "value-chain"
-    ],
-    "weakCategories": ["environmental-impact"],
-    "insufficientCategories": ["economic-displacement"],
-    "completenessScore": 92
-  }
-}

data/evaluations/fraud-detector.json

@@ -1,31 +0,0 @@
-{
-  "id": "4",
-  "systemName": "FraudDetector AI",
-  "provider": "FinTech Solutions",
-  "modality": "Other",
-  "version": "v2.3.1",
-  "deploymentContext": "Production Banking System",
-  "evaluationDate": "2024-12-05",
-  "evaluator": "Internal Risk Team",
-  "selectedCategories": [
-    "problem-solving",
-    "learning-memory",
-    "harmful-content",
-    "information-integrity",
-    "privacy-data",
-    "bias-fairness",
-    "security-robustness",
-    "governance-accountability",
-    "value-chain"
-  ],
-  "overallStats": {
-    "totalApplicable": 9,
-    "capabilityApplicable": 2,
-    "riskApplicable": 7,
-    "strongCategories": ["problem-solving", "privacy-data", "security-robustness", "governance-accountability"],
-    "adequateCategories": ["learning-memory", "information-integrity", "value-chain"],
-    "weakCategories": ["harmful-content", "bias-fairness"],
-    "insufficientCategories": [],
-    "completenessScore": 78
-  }
-}

data/evaluations/gemini-pro.json

@@ -1,58 +0,0 @@
-{
-  "id": "3",
-  "systemName": "Gemini Pro 1.5",
-  "provider": "Google",
-  "modality": "Multimodal",
-  "version": "gemini-1.5-pro-002",
-  "deploymentContext": "API Service",
-  "evaluationDate": "2024-12-08",
-  "evaluator": "Google DeepMind",
-  "selectedCategories": [
-    "language-communication",
-    "social-intelligence",
-    "problem-solving",
-    "creativity-innovation",
-    "learning-memory",
-    "perception-vision",
-    "metacognition",
-    "harmful-content",
-    "information-integrity",
-    "privacy-data",
-    "bias-fairness",
-    "security-robustness",
-    "dangerous-capabilities",
-    "human-ai-interaction",
-    "environmental-impact",
-    "economic-displacement",
-    "governance-accountability",
-    "value-chain"
-  ],
-  "overallStats": {
-    "totalApplicable": 18,
-    "capabilityApplicable": 7,
-    "riskApplicable": 11,
-    "strongCategories": [
-      "language-communication",
-      "problem-solving",
-      "perception-vision",
-      "learning-memory",
-      "metacognition",
-      "information-integrity",
-      "governance-accountability"
-    ],
-    "adequateCategories": [
-      "social-intelligence",
-      "creativity-innovation",
-      "harmful-content",
-      "privacy-data",
-      "security-robustness",
-      "dangerous-capabilities",
-      "human-ai-interaction",
-      "environmental-impact",
-      "value-chain"
-    ],
-    "weakCategories": ["bias-fairness"],
-    "insufficientCategories": ["economic-displacement"],
-    "completenessScore": 87
-  }
-}

data/evaluations/gpt-4-turbo.json

@@ -1,268 +0,0 @@
-{
-  "id": "1",
-  "systemName": "GPT-4 Turbo",
-  "provider": "OpenAI",
-  "modality": "Text-to-Text",
-  "version": "gpt-4-turbo-2024-04-09",
-  "deploymentContext": "API Service",
-  "evaluationDate": "2024-12-15",
-  "evaluator": "OpenAI Safety Team",
-  "selectedCategories": [
-    "language-communication",
-    "social-intelligence",
-    "problem-solving",
-    "creativity-innovation",
-    "learning-memory",
-    "perception-vision",
-    "metacognition",
-    "harmful-content",
-    "information-integrity",
-    "privacy-data",
-    "bias-fairness",
-    "security-robustness",
-    "dangerous-capabilities",
-    "human-ai-interaction",
-    "environmental-impact",
-    "economic-displacement",
-    "governance-accountability",
-    "value-chain"
-  ],
-  "categoryEvaluations": {
-    "language-communication": {
-      "benchmarkAnswers": {
-        "A1": "yes",
-        "A2": "yes",
-        "A3": "yes",
-        "A4": "yes",
-        "A5": "yes",
-        "A6": "yes"
-      },
-      "processAnswers": {
-        "B1": "yes",
-        "B2": "yes",
-        "B5": [
-          "yes"
-        ],
-        "B6": "yes"
-      },
-      "benchmarkSources": {
-        "A1": [
-          {
-            "id": "1",
-            "benchmarkName": "MMLU",
-            "version": "2023-05",
-            "taskVariants": "multiple choice",
-            "metrics": "accuracy",
-            "url": "https://github.com/hendrycks/test",
-            "description": "Massive Multitask Language Understanding benchmark covering 57 academic subjects",
-            "sourceType": "external",
-            "score": "86.4%",
-            "customFields": {}
-          }
-        ],
-        "A2": [
-          {
-            "id": "2",
-            "benchmarkName": "TruthfulQA",
-            "version": "v1.0",
-            "taskVariants": "generation",
-            "metrics": "truthfulness rate",
-            "url": "https://github.com/sylinrl/TruthfulQA",
-            "description": "Measures truthfulness in language models",
-            "sourceType": "external",
-            "score": "Pass - 78% truthful",
-            "customFields": {
-              "thresholds": ">70% truthfulness rate",
-              "regulatorySource": "AI safety guidelines",
-              "complianceStatus": "Compliant"
-            }
-          }
-        ],
-        "A3": [
-          {
-            "id": "3",
-            "benchmarkName": "HellaSwag",
-            "version": "v1.1",
-            "taskVariants": "completion",
-            "metrics": "accuracy",
-            "url": "https://rowanzellers.com/hellaswag/",
-            "description": "Commonsense reasoning benchmark",
-            "sourceType": "external",
-            "score": "95.3%",
-            "customFields": {
-              "comparativeScores": "GPT-4 Turbo: 95.3%, GPT-3.5: 85.5%, Claude-3: 88.0%",
-              "comparisonTargets": "GPT-3.5, Claude-3, Gemini Pro",
-              "significance": "p<0.001, 95% CI: [94.8, 95.8]"
-            }
-          }
-        ],
-        "A4": [
-          {
-            "id": "4",
-            "benchmarkName": "AdvGLUE",
-            "version": "v1.0",
-            "taskVariants": "adversarial",
-            "metrics": "robustness score",
-            "url": "https://adversarialglue.github.io/",
-            "description": "Adversarial evaluation of language understanding",
-            "sourceType": "external",
-            "score": "72.1%",
-            "customFields": {
-              "testTypes": "adversarial attacks, paraphrase attacks, typo attacks",
-              "failureRates": "28% degradation under adversarial inputs",
-              "robustnessMetrics": "attack success rate: 15%, performance drop: 12%"
-            }
-          }
-        ],
-        "A5": [
-          {
-            "id": "5",
-            "benchmarkName": "Production Monitoring",
-            "version": "v2.1",
-            "taskVariants": "live traffic",
-            "metrics": "error rate, latency",
-            "url": "https://openai.com/safety",
-            "description": "Real-time monitoring of production API",
-            "sourceType": "internal",
-            "score": "99.9% uptime",
-            "customFields": {
-              "liveMetrics": "error rates, response latency, content policy violations",
-              "samplingCadence": "every 1000 requests",
-              "alertThresholds": ">1% error rate, >2s latency"
-            }
-          }
-        ],
-        "A6": [
-          {
-            "id": "6",
-            "benchmarkName": "Contamination Analysis",
-            "version": "v1.0",
-            "taskVariants": "overlap detection",
-            "metrics": "contamination rate",
-            "url": "https://openai.com/research/contamination",
-            "description": "Analysis of training-test data overlap",
-            "sourceType": "internal",
-            "score": "<0.5% overlap",
-            "customFields": {
-              "procedure": "13-gram overlap analysis, fuzzy matching, URL deduplication",
-              "contaminationRate": "0.3% exact matches, 0.8% fuzzy matches",
-              "mitigations": "removed overlapping samples, used holdout validation set"
-            }
-          }
-        ]
-      },
-      "processSources": {
-        "B1": [
-          {
-            "id": "7",
-            "url": "https://openai.com/research/language-models",
-            "description": "Language model evaluation methodology and scope definition",
-            "sourceType": "internal",
-            "documentType": "Research Paper",
-            "customFields": {
-              "scope": "Evaluates natural language understanding and generation across diverse domains",
-              "successFailureDefinitions": "Success: >80% on standardized benchmarks, coherent generation",
-              "hypotheses": "Model can understand context and generate human-like responses"
-            }
-          }
-        ],
-        "B2": [
-          {
-            "id": "8",
-            "url": "https://github.com/openai/evals",
-            "description": "OpenAI Evals framework for reproducible evaluations",
-            "sourceType": "external",
-            "documentType": "Code Repository",
-            "customFields": {
-              "replicationPackage": "GitHub repository with evaluation code, prompts, and configurations",
-              "accessLevel": "Public repository with documented APIs",
-              "proxies": "Synthetic examples provided for proprietary benchmarks"
-            }
-          }
-        ],
-        "B5": [
-          {
-            "id": "9",
-            "url": "https://openai.com/safety/practices",
-            "description": "External review process for model evaluations",
-            "sourceType": "cooperative",
-            "documentType": "Process Documentation",
-            "customFields": {
-              "reviewers": "Academic researchers, AI safety experts, domain specialists",
-              "feedbackChanges": "Added bias metrics, revised safety thresholds",
-              "disagreements": "Threshold levels for harmful content detection"
-            }
-          },
-          {
-            "id": "11",
-            "url": "https://openai.com/safety/monitoring",
-            "description": "Continuous monitoring and re-evaluation procedures",
-            "sourceType": "internal",
-            "documentType": "Standard Operating Procedure",
-            "customFields": {
-              "triggers": "Model updates, performance drift >5%, safety incidents",
-              "versionedSpecs": "Evaluation specifications v3.2 with change tracking",
-              "auditTrail": "All changes logged with timestamps and rationale",
-              "mitigationProtocols": "Automated rollback procedures, manual safety review",
-              "retestProcedures": "Full evaluation suite after fixes, regression testing"
-            }
-          }
-        ],
-        "B6": [
-          {
-            "id": "10",
-            "url": "https://openai.com/research/model-cards",
-            "description": "Model card with transparent reporting of capabilities and limitations",
-            "sourceType": "internal",
-            "documentType": "Model Card",
-            "customFields": {
-              "uncertaintyDisclosure": "95% confidence intervals, error bars on all metrics",
-              "axesConsistency": "Consistent 0-100 scale, no truncated axes",
-              "sampleSizes": "n=10,000 test samples, 5 random seeds",
-              "selectionCriteria": "All results reported, no cherry-picking"
-            }
-          }
-        ]
-      },
-      "additionalAspects": "Additional evaluation includes multilingual performance testing across 25 languages, domain-specific evaluations for medical and legal text, and long-context evaluation up to 128k tokens.",
-      "score": {
-        "benchmarkScore": 6,
-        "processScore": 5,
-        "totalScore": 11,
-        "status": "strong"
-      }
-    }
-  },
-  "overallStats": {
-    "totalApplicable": 18,
-    "capabilityApplicable": 7,
-    "riskApplicable": 11,
-    "strongCategories": [
-      "language-communication",
-      "problem-solving",
-      "creativity-innovation",
-      "learning-memory",
-      "metacognition",
-      "governance-accountability"
-    ],
-    "adequateCategories": [
-      "social-intelligence",
-      "perception-vision",
-      "information-integrity",
-      "privacy-data",
-      "security-robustness",
-      "human-ai-interaction",
-      "environmental-impact",
-      "value-chain"
-    ],
-    "weakCategories": [
-      "harmful-content",
-      "bias-fairness",
-      "dangerous-capabilities"
-    ],
-    "insufficientCategories": [
-      "economic-displacement"
-    ],
-    "completenessScore": 89
-  }
-}

lib/category-data.ts

@@ -1,828 +0,0 @@
-export const CATEGORY_DESCRIPTIONS = {
-  "language-communication": {
-    name: "Language & Communication",
-    description:
-      "Evaluates the system's ability to understand, generate, and engage in natural language communication across various contexts, languages, and communication styles.",
-    type: "capability" as const,
-  },
-  "social-intelligence": {
-    name: "Social Intelligence & Interaction",
-    description:
-      "Assesses the system's capacity to understand social contexts, interpret human emotions and intentions, and engage appropriately in social interactions.",
-    type: "capability" as const,
-  },
-  "problem-solving": {
-    name: "Problem Solving",
-    description:
-      "Measures the system's ability to analyze complex problems, develop solutions, and apply reasoning across various domains and contexts.",
-    type: "capability" as const,
-  },
-  "creativity-innovation": {
-    name: "Creativity & Innovation",
-    description:
-      "Evaluates the system's capacity for creative thinking, generating novel ideas, and producing original content across different creative domains.",
-    type: "capability" as const,
-  },
-  "learning-memory": {
-    name: "Learning & Memory",
-    description:
-      "Assesses the system's ability to acquire new knowledge, retain information, and adapt behavior based on experience and feedback.",
-    type: "capability" as const,
-  },
-  "perception-vision": {
-    name: "Perception & Vision",
-    description:
-      "Measures the system's capability to process, interpret, and understand visual information, images, and spatial relationships.",
-    type: "capability" as const,
-  },
-  "physical-manipulation": {
-    name: "Physical Manipulation & Motor Skills",
-    description:
-      "Evaluates the system's ability to control physical actuators, manipulate objects, and perform motor tasks in physical environments.",
-    type: "capability" as const,
-  },
-  metacognition: {
-    name: "Metacognition & Self-Awareness",
-    description:
-      "Assesses the system's ability to understand its own capabilities, limitations, and reasoning processes, including self-reflection and meta-learning.",
-    type: "capability" as const,
-  },
-  "robotic-intelligence": {
-    name: "Robotic Intelligence & Autonomy",
-    description:
-      "Measures autonomous decision-making, navigation, and task execution in physical environments with minimal human intervention.",
-    type: "capability" as const,
-  },
-  "harmful-content": {
-    name: "Harmful Content Generation",
-    description:
-      "Evaluates risks related to generating harmful, offensive, illegal, or inappropriate content that could cause psychological, social, or physical harm.",
-    type: "risk" as const,
-  },
-  "information-integrity": {
-    name: "Information Integrity & Misinformation",
-    description:
-      "Assesses risks of generating false, misleading, or manipulated information that could undermine trust in information systems and decision-making.",
-    type: "risk" as const,
-  },
-  "privacy-data": {
-    name: "Privacy & Data Protection",
-    description:
-      "Evaluates risks to personal privacy, data security, and unauthorized access to or misuse of sensitive personal information.",
-    type: "risk" as const,
-  },
-  "bias-fairness": {
-    name: "Bias & Fairness",
-    description:
-      "Assesses risks of discriminatory outcomes, unfair treatment of different groups, and perpetuation of societal biases and inequalities.",
-    type: "risk" as const,
-  },
-  "security-robustness": {
-    name: "Security & Robustness",
-    description:
-      "Evaluates vulnerabilities to adversarial attacks, system manipulation, and failure modes that could compromise system integrity and reliability.",
-    type: "risk" as const,
-  },
-  "dangerous-capabilities": {
-    name: "Dangerous Capabilities & Misuse",
-    description:
-      "Assesses risks from capabilities that could be misused for harmful purposes, including dual-use applications and potential for weaponization.",
-    type: "risk" as const,
-  },
-  "human-ai-interaction": {
-    name: "Human-AI Interaction Risks",
-    description:
-      "Evaluates risks arising from human-AI interaction patterns, including over-reliance, manipulation, and degradation of human skills and autonomy.",
-    type: "risk" as const,
-  },
-  "environmental-impact": {
-    name: "Environmental & Resource Impact",
-    description:
-      "Evaluates environmental costs of AI development and deployment, including energy consumption, carbon footprint, and resource utilization.",
-    type: "risk" as const,
-  },
-  "economic-displacement": {
-    name: "Economic & Labor Displacement",
-    description:
-      "Evaluates potential economic disruption, job displacement, and impacts on labor markets and economic inequality from AI deployment.",
-    type: "risk" as const,
-  },
-  "governance-accountability": {
-    name: "Governance & Accountability",
-    description:
-      "Assesses risks related to lack of oversight, unclear responsibility structures, and insufficient governance mechanisms for AI systems.",
-    type: "risk" as const,
-  },
-  "value-chain": {
-    name: "Value Chain & Supply Chain Risks",
-    description:
-      "Evaluates risks throughout the AI development and deployment pipeline, including data sourcing, model training, and third-party dependencies.",
-    type: "risk" as const,
-  },
-}
-
-export const SOURCE_TYPES = {
-  internal: {
-    label: "Internal",
-    description:
-      "Evaluations conducted by the organization developing or deploying the AI system using internal resources, teams, and methodologies.",
-  },
-  external: {
-    label: "External",
-    description:
-      "Independent evaluations conducted by third-party organizations, academic institutions, or external auditors without direct involvement from the developing organization.",
-  },
-  cooperative: {
-    label: "Cooperative",
-    description:
-      "Collaborative evaluations involving multiple stakeholders, including the developing organization, external experts, affected communities, and regulatory bodies working together.",
-  },
-} as const
-
-export const BENCHMARK_QUESTIONS = [
-  {
-    id: "A1",
-    text: "Has the system been run on recognized, category-specific benchmarks?",
-    tooltip:
-      "Expect: Benchmark/dataset names & versions, task variants, metric definitions, who ran them (internal/external).",
-    customFields: [],
-  },
-  {
-    id: "A2",
-    text: "Does the system meet pre-set quantitative thresholds for acceptable performance under applicable regulations?",
-    tooltip:
-      "Expect: Numeric scores vs. regulatory/compliance thresholds (e.g., hiring fairness, medical accuracy), source of regulatory requirements, compliance determination.",
-    customFields: ["thresholds", "regulatorySource", "complianceStatus"],
-  },
-  {
-    id: "A3",
-    text: "How does performance compare to baselines, SOTA, previous versions, and other comparable systems?",
-    tooltip:
-      "Expect: Side-by-side comparisons with SOTA models, previous versions, and similar systems under matched conditions, significance tests or confidence intervals for deltas.",
-    customFields: ["comparativeScores", "comparisonTargets", "significance"],
-  },
-  {
-    id: "A4",
-    text: "How does the system perform under adversarial inputs, extreme loads, distribution shift?",
-    tooltip: "Expect: Test types (attack/shift/load), rates of failure/degradation, robustness metrics.",
-    customFields: ["testTypes", "failureRates", "robustnessMetrics"],
-  },
-  {
-    id: "A5",
-    text: "Is performance measured in the wild with automated monitors?",
-    tooltip: "Expect: Live metrics tracked (e.g., error rates, drift, latency), sampling cadence, alert thresholds.",
-    customFields: ["liveMetrics", "samplingCadence", "alertThresholds"],
-  },
-  {
-    id: "A6",
-    text: "Have you quantified train–test overlap or leakage risks that could inflate results?",
-    tooltip:
-      "Expect: Procedure (e.g., n-gram/fuzzy overlap, URL hashing), contamination rate estimates, mitigations taken.",
-    customFields: ["procedure", "contaminationRate", "mitigations"],
-  },
-]
-
-export const PROCESS_QUESTIONS = [
-  {
-    id: "B1",
-    text: "What capability/risk claims is this category evaluating and why it's applicable?",
-    tooltip: "Expect: Clear scope, success/failure definitions, hypotheses the evaluation is testing.",
-    customFields: ["scope", "successFailureDefinitions", "hypotheses"],
-  },
-  {
-    id: "B2",
-    text: "Can others reproduce the results?",
-    tooltip:
-      "Expect: Public or access-controlled release of code/configs, prompts, seeds, decoding settings, dataset IDs/versions, hardware notes; if not shareable, documented proxies.",
-    customFields: ["replicationPackage", "accessLevel", "proxies"],
-  },
-  {
-    id: "B3",
-    text: "Have domain experts/affected users reviewed interpretations of results?",
-    tooltip: "Expect: Who reviewed, what feedback changed, unresolved disagreements and rationale.",
-    customFields: ["reviewers", "feedbackChanges", "disagreements"],
-  },
-  {
-    id: "B4",
-    text: "Do figures communicate results without distortion and with uncertainty/context?",
-    tooltip:
-      "Expect: Uncertainty shown (CI/SE, multi-seed variance), full/consistent axes, sample sizes, like-for-like comparisons, raw tables available, disclosure of selection criteria.",
-    customFields: ["uncertaintyDisclosure", "axesConsistency", "sampleSizes", "selectionCriteria"],
-  },
-  {
-    id: "B5",
-    text: "Standards & Compliance Alignment - Are evaluation practices aligned with relevant organizational, industry, or regulatory standards?",
-    tooltip:
-      "Expect: References to applicable standards/regulations, mapping of evaluation practices to those standards, any gaps or exemptions noted, and plan to address misalignment.",
-    customFields: ["standardsReferenced", "alignmentSummary"],
-  },
-  {
-    id: "B6",
-    text: "Is there a process to re-run/adapt evals as models, data, or risks change, including mitigation and retest procedures?",
-    tooltip:
-      "Expect: Triggers (model updates, drift, incidents), versioned eval specs, scheduled re-assessment cadence, audit trail of changes, mitigation protocols when issues are found, and systematic retest procedures after fixes.",
-    customFields: ["triggers", "versionedSpecs", "auditTrail", "mitigationProtocols", "retestProcedures"],
-  },
-]
-
-export const ADDITIONAL_ASPECTS_SECTION = {
-  id: "C",
-  title: "Additional Evaluation Aspects",
-  description:
-    "Document any other evaluation aspects for this category that may not have been captured by the structured questions above. This section will not be scored but will be visible in the final documentation.",
-}
-
-export const CATEGORY_DETAILED_GUIDANCE = {
-  "language-communication": `Key Benchmarks to Look For:
-General: MMLU, HellaSwag, ARC, WinoGrande
-Reading Comprehension: SQuAD, QuAC, CoQA
-Language Generation: BLEU, ROUGE, BERTScore
-Multilingual: XTREME, XGLUE, mBERT evaluation
-Reasoning: GSM8K, BBH (BIG-Bench Hard)
-Instruction Following: Alpaca Eval, MT-Bench
-
-Evaluation Focus:
-• Semantic understanding across languages
-• Text generation quality and coherence
-• Reasoning and logical inference
-• Context retention in long conversations
-• Factual accuracy and knowledge recall
-
-Common Risk Areas:
-• Hallucination and misinformation generation
-• Bias in language generation
-• Inconsistent performance across languages`,
-
-  "social-intelligence": `Key Benchmarks to Look For:
-Theory of Mind: ToMi, FaINoM, SOTOPIA
-Emotional Intelligence: EmoBench, EQBench
-Social Reasoning: Social IQa, CommonsenseQA
-Dialogue: PersonaChat, BlendedSkillTalk
-Psychology: Psychometrics Benchmark for LLMs
-
-Evaluation Focus:
-• Understanding social cues and context
-• Appropriate emotional responses
-• Maintaining consistent personality
-• Theory of mind reasoning
-• Cultural sensitivity and awareness
-
-Common Risk Areas:
-• Inappropriate anthropomorphization
-• Cultural bias and insensitivity
-• Lack of emotional regulation
-• Manipulation potential`,
-
-  "problem-solving": `Key Benchmarks to Look For:
-Mathematical: GSM8K, MATH, FrontierMath, AIME
-Logical Reasoning: LogiQA, ReClor, FOLIO
-Programming: HumanEval, MBPP, SWE-bench
-Scientific: SciQ, ScienceQA
-Multi-step: StrategyQA, DROP, QuALITY
-
-Evaluation Focus:
-• Multi-step reasoning capability
-• Mathematical and logical problem solving
-• Code generation and debugging
-• Scientific and analytical thinking
-• Planning and strategy development
-
-Common Risk Areas:
-• Reasoning errors in complex problems
-• Inconsistent problem-solving approaches
-• Inability to show work or explain reasoning`,
-
-  "creativity-innovation": `Key Benchmarks to Look For:
-Creative Writing: CREAM, Creative Story Generation
-Visual Creativity: FIQ (Figural Interpretation Quest)
-Alternative Uses: AUT (Alternative Uses Task)
-Artistic Generation: Aesthetic and originality scoring
-Innovation: Novel solution generation tasks
-
-Evaluation Focus:
-• Originality and novelty of outputs
-• Artistic and creative quality
-• Ability to combine concepts innovatively
-• Divergent thinking capabilities
-• Value and usefulness of creative outputs
-
-Common Risk Areas:
-• Copyright and IP infringement
-• Lack of genuine creativity vs. recombination
-• Inappropriate or harmful creative content`,
-
-  "learning-memory": `Key Benchmarks to Look For:
-Few-shot Learning: Omniglot, miniImageNet, Meta-Dataset
-Transfer Learning: VTAB, BigTransfer
-In-context Learning: ICL benchmarks across domains
-Knowledge Retention: Long-term memory tests
-Continual Learning: CORe50, Split-CIFAR
-
-Evaluation Focus:
-• Few-shot and zero-shot learning ability
-• Knowledge transfer across domains
-• Memory retention and recall
-• Adaptation to new tasks
-• Learning efficiency and speed
-
-Common Risk Areas:
-• Catastrophic forgetting
-• Overfitting to limited examples
-• Inability to generalize learned concepts`,
-
-  "perception-vision": `Key Benchmarks to Look For:
-Object Recognition: ImageNet, COCO, Open Images
-Scene Understanding: ADE20K, Cityscapes
-Robustness: ImageNet-C, ImageNet-A
-Multimodal: VQA, CLIP benchmarks
-3D Understanding: NYU Depth, KITTI
-
-Evaluation Focus:
-• Object detection and classification
-• Scene understanding and segmentation
-• Robustness to visual variations
-• Integration with language understanding
-• Real-world deployment performance
-
-Common Risk Areas:
-• Adversarial vulnerability
-• Bias in image recognition
-• Poor performance on edge cases`,
-
-  "physical-manipulation": `Key Benchmarks to Look For:
-Grasping: YCB Object Set, Functional Grasping
-Manipulation: RoboCAS, FMB (Functional Manipulation)
-Assembly: NIST Assembly Task Boards
-Navigation: Habitat, AI2-THOR challenges
-Dexterity: Dexterous manipulation benchmarks
-
-Evaluation Focus:
-• Grasping and manipulation accuracy
-• Adaptability to object variations
-• Force control and delicate handling
-• Spatial reasoning and planning
-• Real-world deployment robustness
-
-Common Risk Areas:
-• Safety in human environments
-• Damage to objects or environment
-• Inconsistent performance across conditions`,
-
-  metacognition: `Key Benchmarks to Look For:
-Confidence Calibration: Calibration metrics, ECE
-Uncertainty Quantification: UQ benchmarks
-Self-Assessment: Metacognitive accuracy tests
-Know-Unknown: Known Unknowns benchmarks
-Error Detection: Self-correction capabilities
-
-Evaluation Focus:
-• Confidence calibration accuracy
-• Uncertainty expression and quantification
-• Self-monitoring and error detection
-• Knowledge boundary awareness
-• Adaptive reasoning based on confidence
-
-Common Risk Areas:
-• Overconfidence in incorrect responses
-• Poor uncertainty quantification
-• Inability to recognize knowledge limits`,
-
-  "robotic-intelligence": `Key Benchmarks to Look For:
-Integrated Tasks: RoboCup, DARPA challenges
-Navigation: Habitat challenges, real-world navigation
-Manipulation: Integrated pick-and-place scenarios
-Human-Robot Interaction: HRI benchmarks
-Autonomy: Long-horizon task completion
-
-Evaluation Focus:
-• Integrated sensorimotor capabilities
-• Autonomous decision-making
-• Adaptability to dynamic environments
-• Human-robot collaboration
-• Long-term task execution
-
-Common Risk Areas:
-• Safety in unstructured environments
-• Unpredictable autonomous behavior
-• Failure to handle edge cases`,
-
-  "harmful-content": `Key Evaluations to Look For:
-Safety Benchmarks: AIR-Bench, MLCommons AI Safety
-Red Teaming: Anthropic Constitutional AI, HarmBench
-Content Filtering: Jigsaw Toxic Comments, HASOC
-Adversarial: Jailbreaking attempts, prompt injection
-Regulatory: NIST AI RMF compliance
-
-Evaluation Focus:
-• Refusal to generate harmful content
-• Robustness against adversarial prompts
-• Content filtering effectiveness
-• Detection of subtle harmful content
-• Consistency across different prompt styles
-
-Critical Risk Areas:
-• Violence and self-harm content
-• Hate speech and discrimination
-• Illegal activity instructions
-• NSFW and inappropriate content`,
-
-  "information-integrity": `Key Evaluations to Look For:
-Factuality: TruthfulQA, FEVER, HaluEval
-Hallucination Detection: SelfCheckGPT, FActScore
-Misinformation: LIAR dataset, fake news detection
-Citation Accuracy: Citation verification benchmarks
-Source Attribution: Provenance tracking tests
-
-Evaluation Focus:
-• Factual accuracy of generated content
-• Hallucination rate and detection
-• Proper source attribution
-• Misinformation resistance
-• Consistency across related queries
-
-Critical Risk Areas:
-• Medical misinformation
-• Political disinformation
-• False historical claims
-• Fabricated citations`,
-
-  "privacy-data": `Key Evaluations to Look For:
-Membership Inference: MIA benchmarks, CopyMark
-Data Extraction: Training data extraction tests
-PII Detection: Personal information leakage tests
-Anonymization: De-identification benchmarks
-GDPR Compliance: Right to be forgotten tests
-
-Evaluation Focus:
-• Training data memorization
-• PII leakage prevention
-• Membership inference resistance
-• Data anonymization effectiveness
-• Compliance with privacy regulations
-
-Critical Risk Areas:
-• Personal information exposure
-• Training data memorization
-• Inference of sensitive attributes
-• Non-consensual data use`,
-
-  "bias-fairness": `Key Evaluations to Look For:
-Bias Benchmarks: Winogender, CrowS-Pairs, BOLD
-Fairness Metrics: AI Fairness 360, Fairlearn
-Demographic Bias: Representation across groups
-Intersectional: Multi-dimensional bias analysis
-Allocative Fairness: Resource distribution equity
-
-Evaluation Focus:
-• Demographic representation fairness
-• Performance equity across groups
-• Intersectional bias analysis
-• Harmful stereotype perpetuation
-• Allocative fairness in decisions
-
-Critical Risk Areas:
-• Employment discrimination
-• Healthcare disparities
-• Educational bias
-• Criminal justice bias`,
-
-  "security-robustness": `Key Evaluations to Look For:
-Adversarial Robustness: AdvBench, RobustBench
-Prompt Injection: AgentDojo, prompt injection tests
-Model Extraction: Model theft resistance
-Backdoor Detection: Trojaned model detection
-OWASP LLM Top 10: Security vulnerability assessment
-
-Evaluation Focus:
-• Adversarial attack resistance
-• Prompt injection robustness
-• Model extraction protection
-• Backdoor and trojan detection
-• Input validation effectiveness
-
-Critical Risk Areas:
-• Prompt injection attacks
-• Model theft and extraction
-• Adversarial examples
-• Supply chain attacks`,
-
-  "dangerous-capabilities": `Key Evaluations to Look For:
-CBRN Assessment: WMD information evaluation
-Dual-Use: Misuse potential analysis
-Cyber Capabilities: Offensive cyber evaluation
-Weapons Information: Dangerous instruction filtering
-Government Protocols: AISI, NIST evaluation standards
-
-Evaluation Focus:
-• CBRN information filtering
-• Dual-use technology assessment
-• Offensive capability evaluation
-• Dangerous instruction refusal
-• Misuse potential quantification
-
-Critical Risk Areas:
-• Chemical/biological weapons info
-• Cyber attack capabilities
-• Physical harm instructions
-• Illegal activity facilitation`,
-
-  "human-ai-interaction": `Key Evaluations to Look For:
-Trust Calibration: Trust-LLM, reliance calibration metrics
-Manipulation Detection: Emotional manipulation detection benchmarks
-Anthropomorphism: Human-likeness perception studies
-Safety in Dialogue: HAX, RealToxicityPrompts
-User Guidance: Task adherence and guidance clarity tests
-
-Evaluation Focus:
-• Preventing over-reliance on AI
-• Avoiding deceptive or manipulative responses
-• Maintaining transparency about capabilities and limitations
-• Providing safe, non-coercive interactions
-• Ensuring user agency and decision-making control
-
-Critical Risk Areas:
-• Emotional manipulation
-• Excessive trust leading to poor decisions
-• Misrepresentation of capabilities
-• Encouraging harmful behaviors`,
-
-  "environmental-impact": `Key Evaluations to Look For:
-Energy Usage: Carbon footprint estimation tools
-Sustainability Metrics: Green AI benchmarks
-Model Efficiency: Inference cost evaluations
-Hardware Utilization: Resource optimization tests
-Lifecycle Assessment: Full training-to-deployment impact analysis
-
-Evaluation Focus:
-• Measuring carbon footprint and energy use
-• Optimizing for efficiency without performance loss
-• Assessing environmental trade-offs
-• Promoting sustainable deployment strategies
-
-Critical Risk Areas:
-• High carbon emissions from training
-• Excessive energy use in inference
-• Lack of transparency in environmental reporting`,
-
-  "economic-displacement": `Key Evaluations to Look For:
-Job Impact Studies: Task automation potential assessments
-Market Disruption: Industry-specific displacement projections
-Economic Modeling: Macro and microeconomic simulations
-Skill Shift Analysis: Required workforce retraining benchmarks
-Societal Impact: Equitable distribution of economic benefits
-
-Evaluation Focus:
-• Predicting job displacement risks
-• Identifying emerging job opportunities
-• Understanding shifts in skill demand
-• Balancing automation benefits with societal costs
-
-Critical Risk Areas:
-• Large-scale unemployment
-• Wage suppression
-• Economic inequality`,
-
-  "governance-accountability": `Key Evaluations to Look For:
-Transparency: Model card completeness, datasheet reporting
-Auditability: Traceability of decisions
-Oversight Mechanisms: Compliance with governance frameworks
-Responsibility Assignment: Clear chain of accountability
-Standards Compliance: ISO, IEEE AI standards adherence
-
-Evaluation Focus:
-• Establishing clear accountability
-• Ensuring decision traceability
-• Meeting compliance and ethical guidelines
-• Maintaining transparency across lifecycle
-
-Critical Risk Areas:
-• Lack of oversight
-• Unclear responsibility in failures
-• Insufficient transparency`,
-
-  "value-chain": `Key Evaluations to Look For:
-Provenance Tracking: Dataset and component origin verification
-Third-Party Risk Assessment: Vendor dependency evaluations
-Supply Chain Security: Software and hardware integrity checks
-Integration Testing: Risk assessment in system integration
-Traceability: End-to-end component documentation
-
-Evaluation Focus:
-• Managing third-party dependencies
-• Verifying component provenance
-• Securing the supply chain
-• Mitigating integration risks
-
-Critical Risk Areas:
-• Compromised third-party components
-• Data provenance issues
-• Vendor lock-in and dependency risks`,
-}
-
-export const CATEGORIES = Object.entries(CATEGORY_DESCRIPTIONS).map(([id, data]) => ({
-  id,
-  ...data,
-  detailedGuidance: CATEGORY_DETAILED_GUIDANCE[id as keyof typeof CATEGORY_DETAILED_GUIDANCE] || "",
-}))
-
-// Centralized hint mappings and recommended placeholders used by the UI.
-export const CATEGORY_HINTS: Record<string, { benchmark: string; process: string }> = {
-  "language-communication": {
-    benchmark:
-      "Hint: mention benchmarks for language understanding/generation, prompt settings, multilingual splits, and whether factuality checks were performed.",
-    process:
-      "Hint: note consulted linguists or annotators, dataset provenance concerns, and any applicable content/regulatory considerations.",
-  },
-  "social-intelligence": {
-    benchmark: "Hint: mention emotion/social reasoning benchmarks used, annotator protocols, and demographic coverage.",
-    process: "Hint: list consulted domain experts (psychologists, sociologists), user study details, and consent/ethics notes.",
-  },
-  "problem-solving": {
-    benchmark: "Hint: list math/programming/reasoning benchmarks, scoring rules, and seed/temperature settings.",
-    process: "Hint: note expert reviewers, validation of solutions, and how ambiguous answers were adjudicated.",
-  },
-  "creativity-innovation": {
-    benchmark: "Hint: mention creative evaluation setups, human rating protocols, and diversity of prompts/tasks.",
-    process: "Hint: note creative experts or juries consulted, copyright/IP checks, and content filtering policies.",
-  },
-  "learning-memory": {
-    benchmark: "Hint: indicate few-shot/transfer benchmarks, replay/continual learning setups, and sample sizes.",
-    process: "Hint: describe retention tests, dataset refresh cadence, and any contamination checks performed.",
-  },
-  "perception-vision": {
-    benchmark: "Hint: list vision datasets, augmentation/robustness tests, and evaluation resolutions/settings.",
-    process: "Hint: note labelling protocols, demographic coverage of imagery, and reviewer/ethical considerations.",
-  },
-  "physical-manipulation": {
-    benchmark: "Hint: mention robotics tasks, real/sim evaluation conditions, and safety/collision metrics.",
-    process: "Hint: include safety review notes, field test observers, and incident mitigation procedures.",
-  },
-  "metacognition": {
-    benchmark: "Hint: report calibration metrics, uncertainty quantification methods, and multi-seed variance.",
-    process: "Hint: list reviewers who evaluated uncertainty reporting and any user-facing confidence disclosures.",
-  },
-  "robotic-intelligence": {
-    benchmark: "Hint: note integrated task suites, sim-to-real gaps, and hardware/configuration details.",
-    process: "Hint: document safety reviews, human-in-the-loop safeguards, and autonomy limits.",
-  },
-  "harmful-content": {
-    benchmark: "Hint: describe toxicity/harm benchmarks, prompt hardening, and red-team scenarios used.",
-    process: "Hint: list safety reviewers, incident response plans, and content moderation policies referenced.",
-  },
-  "information-integrity": {
-    benchmark: "Hint: mention fact-checking datasets, prompt calibrations, and hallucination detection metrics.",
-    process: "Hint: note expert fact-checkers consulted, provenance practices, and external audit reports.",
-  },
-  "privacy-data": {
-    benchmark: "Hint: include privacy tests, membership inference/MI defenses, and redaction results.",
-    process: "Hint: list privacy officers consulted, data handling policies, and any regulatory mappings (e.g., GDPR).",
-  },
-  "bias-fairness": {
-    benchmark: "Hint: indicate fairness metrics, subgroup breakdowns, and statistical significance of gaps.",
-    process: "Hint: document which stakeholder groups and domain experts were engaged and mitigation steps taken.",
-  },
-  "security-robustness": {
-    benchmark: "Hint: report adversarial tests, perturbation strengths, and failure rates under attack.",
-    process: "Hint: include red-team summaries, security reviewers, and incident response procedures.",
-  },
-  "dangerous-capabilities": {
-    benchmark: "Hint: describe tests for dual-use behaviors and misuse scenarios evaluated.",
-    process: "Hint: note external safety reviews, legal counsel input, and controls/mitigations in place.",
-  },
-  "human-ai-interaction": {
-    benchmark: "Hint: list usability/UX tasks, user study protocols, and measures of over-reliance or deception.",
-    process: "Hint: capture which user groups were involved, consent procedures, and human factors reviewers.",
-  },
-  "environmental-impact": {
-    benchmark: "Hint: report energy/perf tradeoff tests, FLOPs/throughput, and measured carbon estimates.",
-    process: "Hint: include sustainability reviewers, lifecycle assessment notes, and mitigation plans.",
-  },
-  "economic-displacement": {
-    benchmark: "Hint: mention labor-impact scenarios evaluated and economic modeling assumptions used.",
-    process: "Hint: document stakeholder consultations, affected worker groups engaged, and mitigation strategies.",
-  },
-  "governance-accountability": {
-    benchmark: "Hint: N/A for benchmarking; focus on process evidence instead.",
-    process: "Hint: cite governance frameworks used, responsible owners, and escalation/audit trails.",
-  },
-  "value-chain": {
-    benchmark: "Hint: include supply-chain dependency tests, third-party component assessments if applicable.",
-    process: "Hint: note vendor audits, data sourcing reviews, and contractual safeguards.",
-  },
-}
-
-export const CATEGORY_QUESTION_HINTS: Record<
-  string,
-  Record<string, { benchmark?: string; process?: string }>
-> = {
-  "language-communication": {
-    A1: { benchmark: "List exact language benchmarks, dataset versions, prompt templates, split (train/val/test), and evaluation conditions." },
-    A2: { benchmark: "State numeric thresholds and which regulatory or domain thresholds apply (e.g., accuracy, FPR/FNR targets)." },
-    A3: { benchmark: "Provide side-by-side comparisons vs. baselines/SOTA, significance tests, and matched prompt/hyperparams." },
-    A4: { benchmark: "Describe adversarial or distribution-shift tests (prompt perturbations, paraphrase attacks) and failure rates." },
-    A5: { benchmark: "Explain live monitoring metrics (latency, error rate, hallucination rate), sampling cadence, and alert rules." },
-    A6: { benchmark: "Document overlap checks (n‑gram, URL hashing), contamination rates, and mitigation steps taken." },
-    B1: { process: "Define scope, claims being evaluated, success criteria (e.g., BLEU/F1 cutoffs), and evaluation hypotheses." },
-    B2: { process: "List reproducibility artifacts (code, prompts, seeds), availability level, and proxies if materials are restricted." },
-    B3: { process: "Name reviewers (linguists, annotators), review protocol, and how feedback was incorporated or adjudicated." },
-    B4: { process: "Show how figures present uncertainty (CI, SE), axes choices, sample sizes, and raw tables for transparency." },
-    B5: { process: "Reference any applicable standards (e.g., ISO, domain regs), mapping to practices, and noted gaps." },
-    B6: { process: "Describe re-eval triggers (model updates, drift), versioned specs, audit trails, and retest procedures." },
-  },
-
-  "social-intelligence": {
-    A1: { benchmark: "Cite emotion/social reasoning datasets, demographic breakdowns, and versioned splits used." },
-    A2: { benchmark: "Specify thresholds for social safety metrics or fairness targets and how they were derived." },
-    A3: { benchmark: "Compare against human baselines and prior models; include inter-rater agreement for subjective tasks." },
-    A4: { benchmark: "Report robustness to adversarial roleplays, toxic prompts, or context manipulation and failure patterns." },
-    A5: { benchmark: "Document in-field monitoring of social interactions, escalations, and rates of inappropriate responses." },
-    A6: { benchmark: "Show contamination checks for dialogue datasets and steps to remove sensitive or toxic examples." },
-    B1: { process: "Explain the claim scope (e.g., empathy, intent detection) and how applicability was determined." },
-    B2: { process: "Provide reproduction artifacts or explain why dialogue data/prompts cannot be shared and offer proxies." },
-    B3: { process: "List domain experts (psychologists, sociologists), study protocols, consent, and key feedback items." },
-    B4: { process: "Ensure visualizations include uncertainty in subjective ratings and avoid misleading aggregations." },
-    B5: { process: "Map evaluation to relevant ethical or safety standards and note any compliance gaps." },
-    B6: { process: "Describe monitoring cadence for social harms, incident playbooks, and retest triggers after fixes." },
-  },
-
-  "problem-solving": {
-    A1: { benchmark: "List math/reasoning/code benchmarks used (GSM8K, MATH, HumanEval) and configuration details." },
-    A2: { benchmark: "State numeric performance thresholds (e.g., pass rates) and how they map to acceptance criteria." },
-    A3: { benchmark: "Provide baselines, previous-version comparisons, and statistical tests for score deltas." },
-    A4: { benchmark: "Describe stress tests (noisy inputs, truncated context) and observed degradation rates." },
-    A5: { benchmark: "Note any online monitoring of problem-solving failures and metrics for automated quality checks." },
-    A6: { benchmark: "Document train/test overlap with known solution sources and contamination mitigation steps." },
-    B1: { process: "Clarify which problem-solving claims are evaluated and define success/failure concretely." },
-    B2: { process: "Provide replication packages (notebooks, seeds) or explain access restrictions and proxies." },
-    B3: { process: "Record expert reviewers (domain experts, graders), rubric instructions, and adjudication rules." },
-    B4: { process: "Include uncertainty (multi-seed variance), example failures, and full result tables for transparency." },
-    B5: { process: "Note alignment with domain standards (education, clinical) and list any exemptions or gaps." },
-    B6: { process: "Describe scheduled re-evals after model updates and procedures for retesting failing cases." },
-  },
-
-  // (other category question hints omitted for brevity - full set can be expanded later)
-}
-
-export const RECOMMENDED_BENCHMARKS: Record<string, string> = {
-  "language-communication": "e.g., MMLU, BBH, SuperGLUE",
-  "social-intelligence": "e.g., SocialIQA, EmoBench, PersonaChat (human-eval)",
-  "problem-solving": "e.g., GSM8K, MATH, HumanEval",
-  "creativity-innovation": "e.g., human preference studies, CREAM (human-eval)",
-  "learning-memory": "e.g., few-shot transfer suites, continual-learning benchmarks",
-  "perception-vision": "e.g., ImageNet, COCO, VQA",
-  "physical-manipulation": "e.g., RoboSuite, YCB benchmarks, real/sim task suites",
-  "metacognition": "e.g., calibration datasets (ECE), uncertainty benchmarks",
-  "robotic-intelligence": "e.g., Habitat, AI2-THOR, DARPA challenge tasks",
-  "harmful-content": "e.g., toxicity/harm benchmarks like ToxicBERT evals, red-team suites",
-  "information-integrity": "e.g., FEVER, fact-checking datasets, hallucination benchmarks",
-  "privacy-data": "e.g., membership-inference tests, MI challenge datasets",
-  "bias-fairness": "e.g., fairness benchmark suites (subgroup metrics), demographic breakdown tests",
-  "security-robustness": "e.g., adversarial robustness suites, attack-replay benchmarks",
-  "dangerous-capabilities": "e.g., dual-use/red-team evaluation suites (internal or published)",
-  "human-ai-interaction": "e.g., user-study protocols, SUS, human preference tests",
-  "environmental-impact": "e.g., FLOPs/energy measurement reports, carbon accounting tests",
-  "economic-displacement": "e.g., scenario/projection models, labor-impact analyses",
-  "governance-accountability": "e.g., audit logs, governance checklists (process evidence)",
-  "value-chain": "e.g., third-party audit reports, supply-chain assessments",
-}
-
-export const RECOMMENDED_METRICS: Record<string, string> = {
-  "language-communication": "e.g., accuracy, F1, BLEU, ROUGE, BERTScore",
-  "social-intelligence": "e.g., human rating scores, agreement rates, F1 for intent detection",
-  "problem-solving": "e.g., exact-match, pass@k, accuracy, solution correctness percentage",
-  "creativity-innovation": "e.g., human preference %, novelty/diversity scores",
-  "learning-memory": "e.g., few-shot accuracy, retention rate, forgetting metric",
-  "perception-vision": "e.g., mAP, IoU, top-1/top-5 accuracy",
-  "physical-manipulation": "e.g., success rate, collision rate, completion time",
-  "metacognition": "e.g., ECE, calibration error, confidence-accuracy correlation",
-  "robotic-intelligence": "e.g., task success rate, path efficiency, failure modes count",
-  "harmful-content": "e.g., toxicity rate, harmful-response rate, false negative rate for filters",
-  "information-integrity": "e.g., precision/recall of fact-checking, citation accuracy",
-  "privacy-data": "e.g., membership inference advantage, reconstruction error rates",
-  "bias-fairness": "e.g., subgroup parity gaps, disparate impact ratios, statistical significance",
-  "security-robustness": "e.g., attack success rate, robustness delta under perturbation",
-  "dangerous-capabilities": "e.g., misuse rate under red-team prompts, severity counts",
-  "human-ai-interaction": "e.g., SUS, task completion rate, user satisfaction scores",
-  "environmental-impact": "e.g., energy per inference, carbon per training run",
-  "economic-displacement": "e.g., projected job impact metrics, economic sensitivity metrics",
-  "governance-accountability": "e.g., audit coverage %, policy alignment scoring",
-  "value-chain": "e.g., vendor risk scores, dependency vulnerability counts",
-}
-
-export const defaultHints = {
-  benchmark: "Hint: include relevant benchmark settings, scoring rules, and notable limitations.",
-  process: "Hint: mention reviewers consulted, applicable standards/regulations, and scope limitations.",
-}
-
-export function getFieldPlaceholder(categoryId: string, questionId: string, field: "benchmarkName" | "metrics") {
-  if (field === "benchmarkName") return RECOMMENDED_BENCHMARKS[categoryId] || "e.g., MMLU, HellaSwag, GSM8K"
-  return RECOMMENDED_METRICS[categoryId] || "e.g., accuracy, F1, BLEU, perplexity"
-}
-
-export function getHint(categoryId: string, questionId: string, section: "benchmark" | "process") {
-  const catQ = CATEGORY_QUESTION_HINTS[categoryId]
-  const qHints = catQ ? catQ[questionId] : undefined
-  if (qHints && qHints[section]) return qHints[section]
-  if (CATEGORY_HINTS[categoryId] && CATEGORY_HINTS[categoryId][section]) return CATEGORY_HINTS[categoryId][section]
-  return defaultHints[section]
-}

lib/schema.ts

@@ -0,0 +1,83 @@
+import schema from '@/schema/evaluation-schema.json'
+import categoryDetails from '@/schema/category-details.json'
+import formHints from '@/schema/form-hints.json'
+import systemInfoSchema from '@/schema/system-info-schema.json'
+
+export type Category = {
+  id: string
+  name: string
+  description: string
+  type: 'capability' | 'risk'
+  detailedGuidance?: string
+}
+
+export type Question = {
+  id: string
+  text: string
+  tooltip?: string
+  hint?: string
+  customFields?: string[]
+}
+
+const raw = schema as {
+  version: string
+  categories: Array<{ id: string; name: string; type: 'capability' | 'risk' }>
+  benchmarkQuestions: Question[]
+  processQuestions: Question[]
+}
+
+// Merge in descriptions from category details
+const data = {
+  version: raw.version,
+  categories: raw.categories.map((c) => ({ 
+    ...c, 
+    description: (categoryDetails.categories as any)[c.id]?.description || '',
+    detailedGuidance: (categoryDetails.categories as any)[c.id]?.detailedGuidance || '' 
+  })) as Category[],
+  benchmarkQuestions: raw.benchmarkQuestions,
+  processQuestions: raw.processQuestions,
+}
+
+export function getAllCategories() {
+  return data.categories
+}
+
+export function getCategoryById(id: string) {
+  return data.categories.find((c) => c.id === id)
+}
+
+export function getBenchmarkQuestions() {
+  return data.benchmarkQuestions
+}
+
+export function getProcessQuestions() {
+  return data.processQuestions
+}
+
+// Export form utilities from schema
+export const SOURCE_TYPES = formHints.sourceTypes
+export const ADDITIONAL_ASPECTS_SECTION = formHints.additionalAspectsSection
+
+// Form hint utilities from schema
+export function getFieldPlaceholder(categoryId: string, field: "benchmarkName" | "metrics") {
+  if (field === "benchmarkName") return (formHints.recommendedBenchmarks as any)[categoryId] || "e.g., MMLU, HellaSwag, GSM8K"
+  return (formHints.recommendedMetrics as any)[categoryId] || "e.g., accuracy, F1, BLEU, perplexity"
+}
+
+export function getHint(categoryId: string, questionId: string, section: "benchmark" | "process") {
+  const catQ = (formHints.categoryQuestionHints as any)[categoryId]
+  const qHints = catQ ? catQ[questionId] : undefined
+  if (qHints && qHints[section]) return qHints[section]
+  if ((formHints.categoryHints as any)[categoryId] && (formHints.categoryHints as any)[categoryId][section]) return (formHints.categoryHints as any)[categoryId][section]
+  return (formHints.defaultHints as any)[section]
+}
+
+export function getSystemInfoFormOptions() {
+  return systemInfoSchema.formOptions
+}
+
+export function getSystemInfoSchema() {
+  return systemInfoSchema.systemInfo
+}
+
+export default data

package.json

@@ -53,6 +53,7 @@
     "react-day-picker": "9.8.0",
     "react-dom": "^19",
     "react-hook-form": "^7.60.0",
+    "react-is": "^19.1.1",
     "react-resizable-panels": "^2.1.7",
     "recharts": "latest",
     "sonner": "^1.7.4",
@@ -68,8 +69,8 @@
     "@types/react-dom": "^19",
     "postcss": "^8.5",
     "tailwindcss": "^4.1.9",
-  "tw-animate-css": "1.3.3",
-  "typescript": "^5",
-  "vitest": "^1.1.5"
+    "tw-animate-css": "1.3.3",
+    "typescript": "^5",
+    "vitest": "^1.1.5"
   }
 }

pnpm-lock.yaml

@@ -137,6 +137,9 @@ importers:
       react-hook-form:
         specifier: ^7.60.0
         version: 7.62.0([email protected])
+      react-is:
+        specifier: ^19.1.1
+        version: 19.1.1
       react-resizable-panels:
         specifier: ^2.1.7
         version: 2.1.9([email protected]([email protected]))([email protected])

public/evaluations/claude-3-sonnet.json

@@ -1,12 +1,17 @@
 {
   "id": "claude-3-sonnet-2024",
   "systemName": "Claude 3.5 Sonnet",
+  "url": "https://claude.ai",
   "provider": "Anthropic",
   "version": "claude-3-5-sonnet-20241022",
-  "modality": "text-to-text",
-  "evaluationDate": "2024-01-10",
-  "deploymentContext": "Production API",
-  "evaluator": "Anthropic Safety Team",
+  "modelTag": "claude-3-5-sonnet-20241022",
+  "knowledgeCutoff": "2024-04-01",
+  "modelType": "foundational",
+  "inputModalities": ["Text", "Image"],
+  "outputModalities": ["Text"],
+  "deploymentContexts": ["Public/Consumer-Facing", "Internal/Enterprise Use"],
+  "evaluationDate": "2024-11-15",
+  "evaluator": "Anthropic Constitutional AI Team",
   "selectedCategories": [
     "language-communication",
     "problem-solving",
@@ -33,38 +38,38 @@
     "totalApplicable": 20,
     "capabilityApplicable": 9,
     "riskApplicable": 11,
-    "completenessScore": 88,
+    "completenessScore": 96,
     "strongCategories": [
       "language-communication",
-      "social-intelligence",
-      "problem-solving",
+      "social-intelligence", 
       "creativity-innovation",
       "harmful-content",
-      "information-integrity",
       "bias-fairness",
-      "human-ai-interaction"
+      "information-integrity",
+      "human-ai-interaction",
+      "governance-accountability"
     ],
     "adequateCategories": [
+      "problem-solving",
       "learning-memory",
       "perception-vision",
       "metacognition",
       "privacy-data",
-      "security-robustness",
-      "governance-accountability"
+      "security-robustness"
     ],
     "weakCategories": [
-      "physical-manipulation",
-      "robotic-intelligence",
       "dangerous-capabilities",
-      "environmental-impact"
+      "environmental-impact",
+      "economic-displacement"
     ],
     "insufficientCategories": [
-      "economic-displacement",
+      "physical-manipulation",
+      "robotic-intelligence",
       "value-chain"
     ],
     "priorityAreas": [
+      "dangerous-capabilities",
       "environmental-impact",
-      "economic-displacement",
       "value-chain"
     ]
   },
@@ -89,29 +94,29 @@
       "benchmarkSources": {
         "A1": [
           {
-            "id": "bench-meem78cs-gs27k1",
+            "id": "bench-claude35s-lc-001",
             "url": "https://www.anthropic.com/news/claude-3-family",
-            "description": "Claude 3.5 Sonnet performance on language understanding benchmarks",
+            "description": "Claude 3.5 Sonnet performance across comprehensive language understanding and generation tasks",
             "sourceType": "external",
-            "benchmarkName": "MMLU, HellaSwag, ARC, WinoGrande",
-            "metrics": "Accuracy, coherence score",
-            "score": "88.7% on MMLU, 95.4% on HellaSwag",
-            "version": "",
-            "taskVariants": "",
+            "benchmarkName": "MMLU, HellaSwag, ARC-Challenge, WinoGrande, GSM8K",
+            "metrics": "Accuracy on reasoning and knowledge tasks",
+            "score": "88.7% MMLU, 95.4% HellaSwag, 96.4% ARC-C, 89.0% WinoGrande, 96.4% GSM8K",
+            "version": "claude-3-5-sonnet-20241022",
+            "taskVariants": "academic-knowledge, commonsense-reasoning, math-reasoning, reading-comprehension",
             "customFields": {}
           }
         ],
         "A2": [
           {
-            "id": "bench-meem78cs-ntiiq7",
+            "id": "bench-claude35s-lc-002",
             "url": "https://www.anthropic.com/safety",
-            "description": "Constitutional AI safety evaluation results",
+            "description": "Constitutional AI evaluation showing strong safety alignment and helpful refusal patterns",
             "sourceType": "internal",
-            "benchmarkName": "",
-            "metrics": "",
-            "score": "",
-            "version": "",
-            "taskVariants": "",
+            "benchmarkName": "Anthropic HHH Eval, Constitutional AI Safety Suite",
+            "metrics": "Helpfulness, harmlessness, honesty scores",
+            "score": "92% helpfulness, 97% harmlessness, 89% honesty",
+            "version": "v3.5",
+            "taskVariants": "safety-alignment, constitutional-ai, harmlessness",
             "customFields": {}
           }
         ],

public/evaluations/fraud-detector.json

@@ -1,10 +1,17 @@
 {
   "id": "fraud-detector-2024",
-  "systemName": "FraudDetector AI",
-  "provider": "FinTech Solutions",
-  "modality": "text-to-text",
-  "evaluationDate": "2024-01-05",
-  "evaluator": "FinTech Risk Team",
+  "systemName": "FraudShield AI Pro",
+  "url": "https://securebank.com/fraudshield",
+  "provider": "SecureBank Technologies",
+  "version": "v3.2.1",
+  "modelTag": "fraudshield-v3.2.1",
+  "knowledgeCutoff": "2024-06-01",
+  "modelType": "fine-tuned",
+  "inputModalities": ["Tabular"],
+  "outputModalities": ["Tabular"],
+  "deploymentContexts": ["Internal/Enterprise Use", "High-Risk Applications"],
+  "evaluationDate": "2024-07-10",
+  "evaluator": "SecureBank AI Risk & Compliance Team",
   "selectedCategories": [
     "problem-solving",
     "bias-fairness",
@@ -19,6 +26,38 @@
     "dangerous-capabilities",
     "economic-displacement"
   ],
+  "overallStats": {
+    "totalApplicable": 12,
+    "capabilityApplicable": 4,
+    "riskApplicable": 8,
+    "completenessScore": 78,
+    "strongCategories": [
+      "problem-solving",
+      "security-robustness",
+      "privacy-data",
+      "governance-accountability"
+    ],
+    "adequateCategories": [
+      "learning-memory",
+      "language-communication",
+      "information-integrity"
+    ],
+    "weakCategories": [
+      "bias-fairness",
+      "human-ai-interaction",
+      "harmful-content"
+    ],
+    "insufficientCategories": [
+      "dangerous-capabilities",
+      "economic-displacement"
+    ],
+    "priorityAreas": [
+      "bias-fairness",
+      "human-ai-interaction",
+      "dangerous-capabilities",
+      "economic-displacement"
+    ]
+  },
   "categoryEvaluations": {
     "problem-solving": {
       "benchmarkAnswers": { "A1": "yes", "A2": "N/A", "A3": "yes", "A4": "N/A", "A5": "N/A", "A6": "yes" },
@@ -26,15 +65,29 @@
       "benchmarkSources": {
         "A1": [
           {
-            "id": "fd-bench-ps-1",
-            "url": "https://fintech.example.com/reports/frauddetector/problem-solving",
-            "description": "Internal evaluation on transaction anomaly detection benchmarks",
+            "id": "fds-bench-ps-001",
+            "url": "https://securebank.com/ai-research/fraudshield-evaluation",
+            "description": "Comprehensive evaluation on real-world transaction fraud detection and anomaly identification",
             "sourceType": "internal",
-            "benchmarkName": "FraudBench-TS, Transaction-QA",
-            "metrics": "Precision, recall, AUC",
-            "score": "92% precision",
-            "version": "1.0",
-            "taskVariants": "financial-transactions",
+            "benchmarkName": "SecureBank FraudBench 2024, FinCrime Detection Suite, AML Pattern Recognition",
+            "metrics": "Precision, Recall, F1-Score, AUC-ROC, False Positive Rate",
+            "score": "94.2% precision, 89.7% recall, 91.9% F1, 0.976 AUC-ROC, 0.08% FPR",
+            "version": "v3.2.1",
+            "taskVariants": "credit-card-fraud, wire-transfer-anomalies, suspicious-pattern-detection, velocity-checks",
+            "customFields": {}
+          }
+        ],
+        "A6": [
+          {
+            "id": "fds-bench-ps-002", 
+            "url": "https://securebank.com/compliance/model-validation",
+            "description": "Independent model validation by third-party auditors for regulatory compliance",
+            "sourceType": "external",
+            "benchmarkName": "RegTech Model Validation Suite, OCC Model Risk Guidelines",
+            "metrics": "Model performance stability, governance compliance score",
+            "score": "Grade A model validation, 98.5% compliance score",
+            "version": "Q2-2024",
+            "taskVariants": "regulatory-compliance, model-governance, risk-assessment",
             "customFields": {}
           }
         ],
@@ -83,15 +136,15 @@
       "benchmarkSources": {
         "A1": [
           {
-            "id": "fd-bench-bf-1",
-            "url": "https://fintech.example.com/reports/fairness",
-            "description": "Internal fairness audits across demographic and merchant segments",
+            "id": "fds-bench-bf-001",
+            "url": "https://securebank.com/responsible-ai/fairness-assessment",
+            "description": "Comprehensive fairness evaluation across protected demographic groups and geographic regions",
             "sourceType": "internal",
-            "benchmarkName": "FairAudit v1",
-            "metrics": "Disparate impact, false positive rate parity",
-            "score": "Acceptable parity across segments",
-            "version": "1.0",
-            "taskVariants": "transactional",
+            "benchmarkName": "Financial Fairness Benchmark 2024, Equal Credit Opportunity Compliance Suite",
+            "metrics": "Demographic parity, equalized odds, false positive rate parity across groups",
+            "score": "0.91 demographic parity, 0.88 equalized odds, <0.05 FPR difference across groups",
+            "version": "v2.1",
+            "taskVariants": "demographic-fairness, geographic-fairness, credit-decisioning, transaction-monitoring",
             "customFields": {}
           }
         ]
@@ -361,34 +414,5 @@
       "processSources": {},
       "additionalAspects": "Not applicable — detailed value-chain and supply-chain risk analysis is beyond the scope of this demo fixture."
     }
-  },
-  "overallStats": {
-    "totalApplicable": 12,
-    "capabilityApplicable": 4,
-    "riskApplicable": 8,
-    "strongCategories": [
-      "problem-solving",
-      "bias-fairness",
-      "security-robustness",
-      "governance-accountability"
-    ],
-    "adequateCategories": [
-      "learning-memory",
-      "privacy-data",
-      "human-ai-interaction"
-    ],
-    "weakCategories": [
-      "language-communication",
-      "harmful-content",
-      "information-integrity"
-    ],
-    "insufficientCategories": [
-      "dangerous-capabilities",
-      "economic-displacement"
-    ],
-    "priorityAreas": [
-      "information-integrity",
-      "harmful-content"
-    ]
   }
 }

public/evaluations/gemini-pro.json

@@ -1,12 +1,17 @@
 {
   "id": "gemini-pro-2024",
   "systemName": "Gemini Pro 1.5",
+  "url": "https://gemini.google.com",
   "provider": "Google",
-  "version": "gemini-1.5-pro-001",
-  "modality": "multimodal",
-  "evaluationDate": "2024-01-08",
-  "deploymentContext": "Production API",
-  "evaluator": "Google DeepMind Safety Team",
+  "version": "gemini-1.5-pro-002",
+  "modelTag": "gemini-1.5-pro-002",
+  "knowledgeCutoff": "2024-02-01",
+  "modelType": "foundational",
+  "inputModalities": ["Text", "Image", "Video", "Audio"],
+  "outputModalities": ["Text", "Image"],
+  "deploymentContexts": ["Public/Consumer-Facing", "Internal/Enterprise Use"],
+  "evaluationDate": "2024-08-20",
+  "evaluator": "Google DeepMind Safety & Responsibility Team",
   "selectedCategories": [
     "language-communication",
     "problem-solving",
@@ -33,15 +38,14 @@
     "totalApplicable": 20,
     "capabilityApplicable": 9,
     "riskApplicable": 11,
-    "completenessScore": 85,
+    "completenessScore": 89,
     "strongCategories": [
       "language-communication",
       "problem-solving",
       "perception-vision",
       "learning-memory",
       "information-integrity",
-      "privacy-data",
-      "security-robustness"
+      "privacy-data"
     ],
     "adequateCategories": [
       "social-intelligence",
@@ -49,24 +53,25 @@
       "metacognition",
       "harmful-content",
       "bias-fairness",
-      "human-ai-interaction"
+      "security-robustness",
+      "human-ai-interaction",
+      "governance-accountability"
     ],
     "weakCategories": [
-      "physical-manipulation",
-      "robotic-intelligence",
       "dangerous-capabilities",
-      "governance-accountability"
+      "environmental-impact"
     ],
     "insufficientCategories": [
-      "environmental-impact",
+      "physical-manipulation",
+      "robotic-intelligence",
       "economic-displacement",
       "value-chain"
     ],
     "priorityAreas": [
-      "physical-manipulation",
-      "robotic-intelligence",
-      "governance-accountability",
-      "environmental-impact"
+      "bias-fairness",
+      "dangerous-capabilities",
+      "environmental-impact",
+      "economic-displacement"
     ]
   },
   "categoryEvaluations": {
@@ -90,29 +95,29 @@
       "benchmarkSources": {
         "A1": [
           {
-            "id": "bench-meem78cz-yf0a7e",
+            "id": "bench-gemini15p-lc-001",
             "url": "https://deepmind.google/technologies/gemini/",
-            "description": "Gemini Pro 1.5 language understanding benchmark results",
+            "description": "Gemini Pro 1.5 comprehensive language understanding and generation evaluation",
             "sourceType": "external",
-            "benchmarkName": "MMLU, HellaSwag, ARC, GSM8K, HumanEval",
-            "metrics": "Accuracy, reasoning score, multilingual performance",
-            "score": "83.7% on MMLU, 87.8% on GSM8K, 71.9% on HumanEval",
-            "version": "",
-            "taskVariants": "",
+            "benchmarkName": "MMLU, HellaSwag, ARC-Challenge, GSM8K, HumanEval, MGSM",
+            "metrics": "Accuracy across reasoning, knowledge, and coding tasks",
+            "score": "83.7% MMLU, 94.4% HellaSwag, 95.6% ARC-C, 91.7% GSM8K, 71.9% HumanEval, 88.9% MGSM",
+            "version": "gemini-1.5-pro-002",
+            "taskVariants": "academic-knowledge, math-reasoning, code-generation, multilingual-reasoning",
             "customFields": {}
           }
         ],
         "A2": [
           {
-            "id": "bench-meem78cz-pyfyty",
+            "id": "bench-gemini15p-lc-002",
             "url": "https://ai.google/responsibility/",
-            "description": "AI safety evaluation meeting Google's responsible AI principles",
+            "description": "Safety evaluation aligned with Google's responsible AI principles and industry standards",
             "sourceType": "internal",
-            "benchmarkName": "",
-            "metrics": "",
-            "score": "",
-            "version": "",
-            "taskVariants": "",
+            "benchmarkName": "Google Safety Eval Suite, RealToxicityPrompts",
+            "metrics": "Safety compliance rate, toxicity generation rate",
+            "score": "98.5% safety compliance, 0.2% toxicity rate",
+            "version": "v1.5.2",
+            "taskVariants": "safety-compliance, toxicity-detection, responsible-ai",
             "customFields": {}
           }
         ],
@@ -346,15 +351,15 @@
       "benchmarkSources": {
         "A1": [
           {
-            "id": "bench-meem78cz-pz8alo",
+            "id": "bench-gemini15p-pv-001",
             "url": "https://deepmind.google/technologies/gemini/",
-            "description": "Multimodal vision capabilities evaluation",
+            "description": "Comprehensive multimodal vision capabilities evaluation across diverse visual tasks",
             "sourceType": "external",
-            "benchmarkName": "VQA, COCO Captions, TextVQA, ChartQA, DocVQA",
-            "metrics": "Visual understanding accuracy, multimodal reasoning score",
-            "score": "82.3% on VQA, 88.1% on COCO Captions, 74.6% on TextVQA",
-            "version": "",
-            "taskVariants": "",
+            "benchmarkName": "VQAv2, COCO Captions, TextVQA, ChartQA, DocVQA, AI2D, ScienceQA",
+            "metrics": "Visual question answering accuracy, image captioning quality, multimodal reasoning",
+            "score": "77.8% VQAv2, 88.1% COCO Captions, 74.6% TextVQA, 80.8% ChartQA, 88.1% DocVQA, 79.5% AI2D",
+            "version": "gemini-1.5-pro-vision-002",
+            "taskVariants": "visual-qa, image-captioning, chart-analysis, document-understanding, scientific-diagrams",
             "customFields": {}
           }
         ]

public/evaluations/gpt-4-turbo.json

@@ -1,12 +1,17 @@
 {
   "id": "gpt-4-turbo-2024",
   "systemName": "GPT-4 Turbo",
+  "url": "https://openai.com/gpt-4",
   "provider": "OpenAI",
   "version": "gpt-4-turbo-2024-04-09",
-  "modality": "text-to-text",
-  "evaluationDate": "2024-01-15",
-  "deploymentContext": "Production API",
-  "evaluator": "AI Safety Research Team",
+  "modelTag": "gpt-4-turbo-2024-04-09",
+  "knowledgeCutoff": "2024-04-01",
+  "modelType": "foundational",
+  "inputModalities": ["Text", "Image"],
+  "outputModalities": ["Text"],
+  "deploymentContexts": ["Public/Consumer-Facing", "Internal/Enterprise Use", "High-Risk Applications"],
+  "evaluationDate": "2024-05-15",
+  "evaluator": "OpenAI Safety & Alignment Team",
   "selectedCategories": [
     "language-communication",
     "problem-solving",
@@ -33,40 +38,40 @@
     "totalApplicable": 20,
     "capabilityApplicable": 9,
     "riskApplicable": 11,
-    "completenessScore": 92,
+    "completenessScore": 94,
     "strongCategories": [
       "language-communication",
-      "problem-solving",
+      "problem-solving", 
       "creativity-innovation",
       "learning-memory",
-      "harmful-content",
       "information-integrity",
-      "privacy-data"
+      "governance-accountability"
     ],
     "adequateCategories": [
       "social-intelligence",
       "perception-vision",
       "metacognition",
+      "harmful-content",
       "bias-fairness",
+      "privacy-data",
       "security-robustness",
-      "human-ai-interaction",
-      "governance-accountability"
+      "human-ai-interaction"
     ],
     "weakCategories": [
-      "physical-manipulation",
-      "robotic-intelligence",
       "dangerous-capabilities",
-      "environmental-impact",
-      "economic-displacement"
+      "environmental-impact"
     ],
     "insufficientCategories": [
-      "value-chain"
-    ],
-    "priorityAreas": [
       "physical-manipulation",
       "robotic-intelligence",
+      "value-chain",
+      "economic-displacement"
+    ],
+    "priorityAreas": [
+      "bias-fairness",
       "dangerous-capabilities",
-      "value-chain"
+      "environmental-impact",
+      "economic-displacement"
     ]
   },
   "categoryEvaluations": {
@@ -90,29 +95,29 @@
       "benchmarkSources": {
         "A1": [
           {
-            "id": "bench-meem78d1-spb1r7",
+            "id": "bench-gpt4t-lc-001",
             "url": "https://openai.com/research/gpt-4",
-            "description": "GPT-4 technical report showing performance on language understanding benchmarks",
+            "description": "GPT-4 Turbo performance on comprehensive language understanding and generation benchmarks",
             "sourceType": "external",
-            "benchmarkName": "MMLU, HellaSwag, ARC",
-            "metrics": "Accuracy, F1-score",
-            "score": "87.4% on MMLU",
-            "version": "",
-            "taskVariants": "",
+            "benchmarkName": "MMLU, HellaSwag, ARC-Challenge, WinoGrande",
+            "metrics": "Accuracy across multiple choice and generation tasks",
+            "score": "87.4% MMLU, 95.3% HellaSwag, 96.3% ARC-C, 87.5% WinoGrande",
+            "version": "v2024.04",
+            "taskVariants": "academic-knowledge, commonsense-reasoning, reading-comprehension",
             "customFields": {}
           }
         ],
         "A2": [
           {
-            "id": "bench-meem78d1-9tw9cj",
-            "url": "https://openai.com/safety/gpt-4",
-            "description": "Safety evaluation results meeting regulatory standards for language models",
+            "id": "bench-gpt4t-lc-002", 
+            "url": "https://openai.com/safety/gpt-4-system-card",
+            "description": "Safety evaluation demonstrating appropriate refusal of harmful content while maintaining helpfulness",
             "sourceType": "internal",
-            "benchmarkName": "",
-            "metrics": "",
-            "score": "",
-            "version": "",
-            "taskVariants": "",
+            "benchmarkName": "OpenAI Safety Eval Suite, TruthfulQA",
+            "metrics": "Refusal rate on harmful prompts, truthfulness score",
+            "score": "99.1% harmful refusal rate, 83% truthfulness",
+            "version": "v1.2",
+            "taskVariants": "safety-alignment, truthfulness",
             "customFields": {}
           }
         ],

schema/category-details.json

@@ -0,0 +1,125 @@
+{
+  "version": "1.0",
+  "categories": {
+    "language-communication": {
+      "name": "Language & Communication",
+      "description": "Evaluates the system's ability to understand, generate, and engage in natural language communication across various contexts, languages, and communication styles.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nGeneral: MMLU, HellaSwag, ARC, WinoGrande\nReading Comprehension: SQuAD, QuAC, CoQA\nLanguage Generation: BLEU, ROUGE, BERTScore\nMultilingual: XTREME, XGLUE, mBERT evaluation\nReasoning: GSM8K, BBH (BIG-Bench Hard)\nInstruction Following: Alpaca Eval, MT-Bench\n\nEvaluation Focus:\n• Semantic understanding across languages\n• Text generation quality and coherence\n• Reasoning and logical inference\n• Context retention in long conversations\n• Factual accuracy and knowledge recall\n\nCommon Risk Areas:\n• Hallucination and misinformation generation\n• Bias in language generation\n• Inconsistent performance across languages"
+    },
+    "social-intelligence": {
+      "name": "Social Intelligence & Interaction",
+      "description": "Assesses the system's capacity to understand social contexts, interpret human emotions and intentions, and engage appropriately in social interactions.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nTheory of Mind: ToMi, FaINoM, SOTOPIA\nEmotional Intelligence: EmoBench, EQBench\nSocial Reasoning: Social IQa, CommonsenseQA\nDialogue: PersonaChat, BlendedSkillTalk\nPsychology: Psychometrics Benchmark for LLMs\n\nEvaluation Focus:\n• Understanding social cues and context\n• Appropriate emotional responses\n• Maintaining consistent personality\n• Theory of mind reasoning\n• Cultural sensitivity and awareness\n\nCommon Risk Areas:\n• Inappropriate anthropomorphization\n• Cultural bias and insensitivity\n• Lack of emotional regulation\n• Manipulation potential"
+    },
+    "problem-solving": {
+      "name": "Problem Solving",
+      "description": "Measures the system's ability to analyze complex problems, develop solutions, and apply reasoning across various domains and contexts.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nMathematical: GSM8K, MATH, FrontierMath, AIME\nLogical Reasoning: LogiQA, ReClor, FOLIO\nProgramming: HumanEval, MBPP, SWE-bench\nScientific: SciQ, ScienceQA\nMulti-step: StrategyQA, DROP, QuALITY\n\nEvaluation Focus:\n• Multi-step reasoning capability\n• Mathematical and logical problem solving\n• Code generation and debugging\n• Scientific and analytical thinking\n• Planning and strategy development\n\nCommon Risk Areas:\n• Reasoning errors in complex problems\n• Inconsistent problem-solving approaches\n• Inability to show work or explain reasoning"
+    },
+    "creativity-innovation": {
+      "name": "Creativity & Innovation",
+      "description": "Evaluates the system's capacity for creative thinking, generating novel ideas, and producing original content across different creative domains.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nCreative Writing: CREAM, Creative Story Generation\nVisual Creativity: FIQ (Figural Interpretation Quest)\nAlternative Uses: AUT (Alternative Uses Task)\nArtistic Generation: Aesthetic and originality scoring\nInnovation: Novel solution generation tasks\n\nEvaluation Focus:\n• Originality and novelty of outputs\n• Artistic and creative quality\n• Ability to combine concepts innovatively\n• Divergent thinking capabilities\n• Value and usefulness of creative outputs\n\nCommon Risk Areas:\n• Copyright and IP infringement\n• Lack of genuine creativity vs. recombination\n• Inappropriate or harmful creative content"
+    },
+    "learning-memory": {
+      "name": "Learning & Memory",
+      "description": "Assesses the system's ability to acquire new knowledge, retain information, and adapt behavior based on experience and feedback.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nFew-shot Learning: Omniglot, miniImageNet, Meta-Dataset\nTransfer Learning: VTAB, BigTransfer\nIn-context Learning: ICL benchmarks across domains\nKnowledge Retention: Long-term memory tests\nContinual Learning: CORe50, Split-CIFAR\n\nEvaluation Focus:\n• Few-shot and zero-shot learning ability\n• Knowledge transfer across domains\n• Memory retention and recall\n• Adaptation to new tasks\n• Learning efficiency and speed\n\nCommon Risk Areas:\n• Catastrophic forgetting\n• Overfitting to limited examples\n• Inability to generalize learned concepts"
+    },
+    "perception-vision": {
+      "name": "Perception & Vision",
+      "description": "Measures the system's capability to process, interpret, and understand visual information, images, and spatial relationships.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nObject Recognition: ImageNet, COCO, Open Images\nScene Understanding: ADE20K, Cityscapes\nRobustness: ImageNet-C, ImageNet-A\nMultimodal: VQA, CLIP benchmarks\n3D Understanding: NYU Depth, KITTI\n\nEvaluation Focus:\n• Object detection and classification\n• Scene understanding and segmentation\n• Robustness to visual variations\n• Integration with language understanding\n• Real-world deployment performance\n\nCommon Risk Areas:\n• Adversarial vulnerability\n• Bias in image recognition\n• Poor performance on edge cases"
+    },
+    "physical-manipulation": {
+      "name": "Physical Manipulation & Motor Skills",
+      "description": "Evaluates the system's ability to control physical actuators, manipulate objects, and perform motor tasks in physical environments.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nGrasping: YCB Object Set, Functional Grasping\nManipulation: RoboCAS, FMB (Functional Manipulation)\nAssembly: NIST Assembly Task Boards\nNavigation: Habitat, AI2-THOR challenges\nDexterity: Dexterous manipulation benchmarks\n\nEvaluation Focus:\n• Grasping and manipulation accuracy\n• Adaptability to object variations\n• Force control and delicate handling\n• Spatial reasoning and planning\n• Real-world deployment robustness\n\nCommon Risk Areas:\n• Safety in human environments\n• Damage to objects or environment\n• Inconsistent performance across conditions"
+    },
+    "metacognition": {
+      "name": "Metacognition & Self-Awareness",
+      "description": "Assesses the system's ability to understand its own capabilities, limitations, and reasoning processes, including self-reflection and meta-learning.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nConfidence Calibration: Calibration metrics, ECE\nUncertainty Quantification: UQ benchmarks\nSelf-Assessment: Metacognitive accuracy tests\nKnow-Unknown: Known Unknowns benchmarks\nError Detection: Self-correction capabilities\n\nEvaluation Focus:\n• Confidence calibration accuracy\n• Uncertainty expression and quantification\n• Self-monitoring and error detection\n• Knowledge boundary awareness\n• Adaptive reasoning based on confidence\n\nCommon Risk Areas:\n• Overconfidence in incorrect responses\n• Poor uncertainty quantification\n• Inability to recognize knowledge limits"
+    },
+    "robotic-intelligence": {
+      "name": "Robotic Intelligence & Autonomy",
+      "description": "Measures autonomous decision-making, navigation, and task execution in physical environments with minimal human intervention.",
+      "type": "capability",
+      "detailedGuidance": "Key Benchmarks to Look For:\nIntegrated Tasks: RoboCup, DARPA challenges\nNavigation: Habitat challenges, real-world navigation\nManipulation: Integrated pick-and-place scenarios\nHuman-Robot Interaction: HRI benchmarks\nAutonomy: Long-horizon task completion\n\nEvaluation Focus:\n• Integrated sensorimotor capabilities\n• Autonomous decision-making\n• Adaptability to dynamic environments\n• Human-robot collaboration\n• Long-term task execution\n\nCommon Risk Areas:\n• Safety in unstructured environments\n• Unpredictable autonomous behavior\n• Failure to handle edge cases"
+    },
+    "harmful-content": {
+      "name": "Harmful Content Generation",
+      "description": "Evaluates risks related to generating harmful, offensive, illegal, or inappropriate content that could cause psychological, social, or physical harm.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nSafety Benchmarks: AIR-Bench, MLCommons AI Safety\nRed Teaming: Anthropic Constitutional AI, HarmBench\nContent Filtering: Jigsaw Toxic Comments, HASOC\nAdversarial: Jailbreaking attempts, prompt injection\nRegulatory: NIST AI RMF compliance\n\nEvaluation Focus:\n• Refusal to generate harmful content\n• Robustness against adversarial prompts\n• Content filtering effectiveness\n• Detection of subtle harmful content\n• Consistency across different prompt styles\n\nCritical Risk Areas:\n• Violence and self-harm content\n• Hate speech and discrimination\n• Illegal activity instructions\n• NSFW and inappropriate content"
+    },
+    "information-integrity": {
+      "name": "Information Integrity & Misinformation",
+      "description": "Assesses risks of generating false, misleading, or manipulated information that could undermine trust in information systems and decision-making.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nFactuality: TruthfulQA, FEVER, HaluEval\nHallucination Detection: SelfCheckGPT, FActScore\nMisinformation: LIAR dataset, fake news detection\nCitation Accuracy: Citation verification benchmarks\nSource Attribution: Provenance tracking tests\n\nEvaluation Focus:\n• Factual accuracy of generated content\n• Hallucination rate and detection\n• Proper source attribution\n• Misinformation resistance\n• Consistency across related queries\n\nCritical Risk Areas:\n• Medical misinformation\n• Political disinformation\n• False historical claims\n• Fabricated citations"
+    },
+    "privacy-data": {
+      "name": "Privacy & Data Protection",
+      "description": "Evaluates risks to personal privacy, data security, and unauthorized access to or misuse of sensitive personal information.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nMembership Inference: MIA benchmarks, CopyMark\nData Extraction: Training data extraction tests\nPII Detection: Personal information leakage tests\nAnonymization: De-identification benchmarks\nGDPR Compliance: Right to be forgotten tests\n\nEvaluation Focus:\n• Training data memorization\n• PII leakage prevention\n• Membership inference resistance\n• Data anonymization effectiveness\n• Compliance with privacy regulations\n\nCritical Risk Areas:\n• Personal information exposure\n• Training data memorization\n• Inference of sensitive attributes\n• Non-consensual data use"
+    },
+    "bias-fairness": {
+      "name": "Bias & Fairness",
+      "description": "Assesses risks of discriminatory outcomes, unfair treatment of different groups, and perpetuation of societal biases and inequalities.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nBias Benchmarks: Winogender, CrowS-Pairs, BOLD\nFairness Metrics: AI Fairness 360, Fairlearn\nDemographic Bias: Representation across groups\nIntersectional: Multi-dimensional bias analysis\nAllocative Fairness: Resource distribution equity\n\nEvaluation Focus:\n• Demographic representation fairness\n• Performance equity across groups\n• Intersectional bias analysis\n• Harmful stereotype perpetuation\n• Allocative fairness in decisions\n\nCritical Risk Areas:\n• Employment discrimination\n• Healthcare disparities\n• Educational bias\n• Criminal justice bias"
+    },
+    "security-robustness": {
+      "name": "Security & Robustness",
+      "description": "Evaluates vulnerabilities to adversarial attacks, system manipulation, and failure modes that could compromise system integrity and reliability.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nAdversarial Robustness: AdvBench, RobustBench\nPrompt Injection: AgentDojo, prompt injection tests\nModel Extraction: Model theft resistance\nBackdoor Detection: Trojaned model detection\nOWASP LLM Top 10: Security vulnerability assessment\n\nEvaluation Focus:\n• Adversarial attack resistance\n• Prompt injection robustness\n• Model extraction protection\n• Backdoor and trojan detection\n• Input validation effectiveness\n\nCritical Risk Areas:\n• Prompt injection attacks\n• Model theft and extraction\n• Adversarial examples\n• Supply chain attacks"
+    },
+    "dangerous-capabilities": {
+      "name": "Dangerous Capabilities & Misuse",
+      "description": "Assesses risks from capabilities that could be misused for harmful purposes, including dual-use applications and potential for weaponization.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nCBRN Assessment: WMD information evaluation\nDual-Use: Misuse potential analysis\nCyber Capabilities: Offensive cyber evaluation\nWeapons Information: Dangerous instruction filtering\nGovernment Protocols: AISI, NIST evaluation standards\n\nEvaluation Focus:\n• CBRN information filtering\n• Dual-use technology assessment\n• Offensive capability evaluation\n• Dangerous instruction refusal\n• Misuse potential quantification\n\nCritical Risk Areas:\n• Chemical/biological weapons info\n• Cyber attack capabilities\n• Physical harm instructions\n• Illegal activity facilitation"
+    },
+    "human-ai-interaction": {
+      "name": "Human-AI Interaction Risks",
+      "description": "Evaluates risks arising from human-AI interaction patterns, including over-reliance, manipulation, and degradation of human skills and autonomy.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nTrust Calibration: Trust-LLM, reliance calibration metrics\nManipulation Detection: Emotional manipulation detection benchmarks\nAnthropomorphism: Human-likeness perception studies\nSafety in Dialogue: HAX, RealToxicityPrompts\nUser Guidance: Task adherence and guidance clarity tests\n\nEvaluation Focus:\n• Preventing over-reliance on AI\n• Avoiding deceptive or manipulative responses\n• Maintaining transparency about capabilities and limitations\n• Providing safe, non-coercive interactions\n• Ensuring user agency and decision-making control\n\nCritical Risk Areas:\n• Emotional manipulation\n• Excessive trust leading to poor decisions\n• Misrepresentation of capabilities\n• Encouraging harmful behaviors"
+    },
+    "environmental-impact": {
+      "name": "Environmental & Resource Impact",
+      "description": "Evaluates environmental costs of AI development and deployment, including energy consumption, carbon footprint, and resource utilization.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nEnergy Usage: Carbon footprint estimation tools\nSustainability Metrics: Green AI benchmarks\nModel Efficiency: Inference cost evaluations\nHardware Utilization: Resource optimization tests\nLifecycle Assessment: Full training-to-deployment impact analysis\n\nEvaluation Focus:\n• Measuring carbon footprint and energy use\n• Optimizing for efficiency without performance loss\n• Assessing environmental trade-offs\n• Promoting sustainable deployment strategies\n\nCritical Risk Areas:\n• High carbon emissions from training\n• Excessive energy use in inference\n• Lack of transparency in environmental reporting"
+    },
+    "economic-displacement": {
+      "name": "Economic & Labor Displacement",
+      "description": "Evaluates potential economic disruption, job displacement, and impacts on labor markets and economic inequality from AI deployment.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nJob Impact Studies: Task automation potential assessments\nMarket Disruption: Industry-specific displacement projections\nEconomic Modeling: Macro and microeconomic simulations\nSkill Shift Analysis: Required workforce retraining benchmarks\nSocietal Impact: Equitable distribution of economic benefits\n\nEvaluation Focus:\n• Predicting job displacement risks\n• Identifying emerging job opportunities\n• Understanding shifts in skill demand\n• Balancing automation benefits with societal costs\n\nCritical Risk Areas:\n• Large-scale unemployment\n• Wage suppression\n• Economic inequality"
+    },
+    "governance-accountability": {
+      "name": "Governance & Accountability",
+      "description": "Assesses risks related to lack of oversight, unclear responsibility structures, and insufficient governance mechanisms for AI systems.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nTransparency: Model card completeness, datasheet reporting\nAuditability: Traceability of decisions\nOversight Mechanisms: Compliance with governance frameworks\nResponsibility Assignment: Clear chain of accountability\nStandards Compliance: ISO, IEEE AI standards adherence\n\nEvaluation Focus:\n• Establishing clear accountability\n• Ensuring decision traceability\n• Meeting compliance and ethical guidelines\n• Maintaining transparency across lifecycle\n\nCritical Risk Areas:\n• Lack of oversight\n• Unclear responsibility in failures\n• Insufficient transparency"
+    },
+    "value-chain": {
+      "name": "Value Chain & Supply Chain Risks",
+      "description": "Evaluates risks throughout the AI development and deployment pipeline, including data sourcing, model training, and third-party dependencies.",
+      "type": "risk",
+      "detailedGuidance": "Key Evaluations to Look For:\nProvenance Tracking: Dataset and component origin verification\nThird-Party Risk Assessment: Vendor dependency evaluations\nSupply Chain Security: Software and hardware integrity checks\nIntegration Testing: Risk assessment in system integration\nTraceability: End-to-end component documentation\n\nEvaluation Focus:\n• Managing third-party dependencies\n• Verifying component provenance\n• Securing the supply chain\n• Mitigating integration risks\n\nCritical Risk Areas:\n• Compromised third-party components\n• Data provenance issues\n• Vendor lock-in and dependency risks"
+    }
+  }
+}

schema/evaluation-schema.json

@@ -0,0 +1,121 @@
+{
+  "version": "1.0",
+  "categories": [
+    {"id":"language-communication","name":"Language & Communication","type":"capability"},
+    {"id":"social-intelligence","name":"Social Intelligence & Interaction","type":"capability"},
+    {"id":"problem-solving","name":"Problem Solving","type":"capability"},
+    {"id":"creativity-innovation","name":"Creativity & Innovation","type":"capability"},
+    {"id":"learning-memory","name":"Learning & Memory","type":"capability"},
+    {"id":"perception-vision","name":"Perception & Vision","type":"capability"},
+    {"id":"physical-manipulation","name":"Physical Manipulation & Motor Skills","type":"capability"},
+    {"id":"metacognition","name":"Metacognition & Self-Awareness","type":"capability"},
+    {"id":"robotic-intelligence","name":"Robotic Intelligence & Autonomy","type":"capability"},
+    {"id":"harmful-content","name":"Harmful Content Generation","type":"risk"},
+    {"id":"information-integrity","name":"Information Integrity & Misinformation","type":"risk"},
+    {"id":"privacy-data","name":"Privacy & Data Protection","type":"risk"},
+    {"id":"bias-fairness","name":"Bias & Fairness","type":"risk"},
+    {"id":"security-robustness","name":"Security & Robustness","type":"risk"},
+    {"id":"dangerous-capabilities","name":"Dangerous Capabilities & Misuse","type":"risk"},
+    {"id":"human-ai-interaction","name":"Human-AI Interaction Risks","type":"risk"},
+    {"id":"environmental-impact","name":"Environmental & Resource Impact","type":"risk"},
+    {"id":"economic-displacement","name":"Economic & Labor Displacement","type":"risk"},
+    {"id":"governance-accountability","name":"Governance & Accountability","type":"risk"},
+    {"id":"value-chain","name":"Value Chain & Supply Chain Risks","type":"risk"}
+  ],
+  "benchmarkQuestions": [
+    {
+      "id":"A1",
+      "text":"Has the system been run on recognized, category-specific benchmarks?",
+      "tooltip":"Expect: Benchmark/dataset names & versions, task variants, metric definitions, who ran them (internal/external).",
+      "hint":"List benchmarks, dataset versions and who executed them."
+    },
+    {
+      "id":"A2",
+      "text":"Does the system meet pre-set quantitative thresholds for acceptable performance under applicable regulations?",
+      "tooltip":"Expect: Numeric scores vs. regulatory/compliance thresholds (e.g., hiring fairness, medical accuracy), source of regulatory requirements, compliance determination.",
+      "hint":"Provide numeric scores and regulatory mappings."
+    },
+    {
+      "id":"A3",
+      "text":"How does performance compare to baselines, SOTA, previous versions, and other comparable systems?",
+      "tooltip":"Expect: Side-by-side comparisons with SOTA models, previous versions, and similar systems under matched conditions, significance tests or confidence intervals for deltas.",
+      "hint":"Provide comparative scores and targets."
+    },
+    {
+      "id":"A4",
+      "text":"How does the system perform under adversarial inputs, extreme loads, distribution shift?",
+      "tooltip":"Expect: Test types (attack/shift/load), rates of failure/degradation, robustness metrics.",
+      "hint":"Describe stress tests and observed failure rates."
+    },
+    {
+      "id":"A5",
+      "text":"Is performance measured in the wild with automated monitors?",
+      "tooltip":"Expect: Live metrics tracked (e.g., error rates, drift, latency), sampling cadence, alert thresholds.",
+      "hint":"List live metrics and alerting rules."
+    },
+    {
+      "id":"A6",
+      "text":"Have you quantified train–test overlap or leakage risks that could inflate results?",
+      "tooltip":"Expect: Procedure (e.g., n‑gram/fuzzy overlap, URL hashing), contamination rate estimates, mitigations taken.",
+      "hint":"Report contamination checks and mitigation steps."
+    }
+  ],
+  "processQuestions": [
+    {
+      "id":"B1",
+      "text":"What capability/risk claims is this category evaluating and why it's applicable?",
+      "tooltip":"Expect: Clear scope, success/failure definitions, hypotheses the evaluation is testing.",
+      "hint":"Define scope and hypotheses."
+    },
+    {
+      "id":"B2",
+      "text":"Can others reproduce the results?",
+      "tooltip":"Expect: Public or access-controlled release of code/configs, prompts, seeds, decoding settings, dataset IDs/versions, hardware notes; if not shareable, documented proxies.",
+      "hint":"Point to code, data or proxies to reproduce results."
+    },
+    {
+      "id":"B3",
+      "text":"Have domain experts/affected users reviewed interpretations of results?",
+      "tooltip":"Expect: Who reviewed, what feedback changed, unresolved disagreements and rationale.",
+      "hint":"List reviewers and key feedback."
+    },
+    {
+      "id":"B4",
+      "text":"Do figures communicate results without distortion and with uncertainty/context?",
+      "tooltip":"Expect: Uncertainty shown (CI/SE, multi-seed variance), full/consistent axes, sample sizes, like-for-like comparisons, raw tables available, disclosure of selection criteria.",
+      "hint":"Ensure figures include uncertainty disclosures."
+    },
+    {
+      "id":"B5",
+      "text":"Standards & Compliance Alignment - Are evaluation practices aligned with relevant organizational, industry, or regulatory standards?",
+      "tooltip":"Expect: References to applicable standards/regulations, mapping of evaluation practices to those standards, any gaps or exemptions noted, and plan to address misalignment.",
+      "hint":"Map evaluation practices to standards and note gaps."
+    },
+    {
+      "id":"B6",
+      "text":"Is there a process to re-run/adapt evals as models, data, or risks change, including mitigation and retest procedures?",
+      "tooltip":"Expect: Triggers (model updates, drift, incidents), versioned eval specs, scheduled re-assessment cadence, audit trail of changes, mitigation protocols when issues are found, and systematic retest procedures after fixes.",
+      "hint":"Describe triggers and re-evaluation procedures."
+    }
+  ],
+  "benchmarkSourceFields": [
+    {"name":"benchmarkName","label":"Benchmark/Dataset Name","type":"text","placeholder":"e.g., MMLU v1"},
+    {"name":"version","label":"Version","type":"text","placeholder":"e.g., v1.2"},
+    {"name":"taskVariants","label":"Task Variants","type":"text","placeholder":"e.g., multiple choice, generation"},
+    {"name":"metrics","label":"Metrics","type":"text","placeholder":"e.g., accuracy, F1"},
+    {"name":"url","label":"URL","type":"text","placeholder":"https://..."},
+    {"name":"description","label":"Description","type":"textarea","placeholder":"Describe the benchmark or test"},
+    {"name":"sourceType","label":"Source Type","type":"radio","options":[{"value":"internal","label":"Internal"},{"value":"external","label":"External"},{"value":"cooperative","label":"Cooperative"}]},
+    {"name":"score","label":"Score","type":"text","placeholder":"e.g., 85%"},
+    {"name":"confidenceInterval","label":"Confidence Interval","type":"text","placeholder":"e.g., 95% CI [90,94]"}
+  ],
+  "processSourceFields": [
+    {"name":"url","label":"URL","type":"text","placeholder":"https://..."},
+    {"name":"documentType","label":"Document Type","type":"text","placeholder":"e.g., Policy, Procedure"},
+    {"name":"title","label":"Title","type":"text","placeholder":"Document title"},
+    {"name":"author","label":"Author","type":"text","placeholder":"Author or owner"},
+    {"name":"organization","label":"Organization","type":"text","placeholder":"Owning org"},
+    {"name":"date","label":"Date","type":"text","placeholder":"YYYY-MM-DD"},
+    {"name":"description","label":"Description","type":"textarea","placeholder":"Describe the documentation"}
+  ]
+}

schema/form-hints.json

@@ -0,0 +1,167 @@
+{
+  "sourceTypes": {
+    "internal": {
+      "label": "Internal",
+      "description": "Evaluations conducted by the organization developing or deploying the AI system using internal resources, teams, and methodologies."
+    },
+    "external": {
+      "label": "External",
+      "description": "Independent evaluations conducted by third-party organizations, academic institutions, or external auditors without direct involvement from the developing organization."
+    },
+    "cooperative": {
+      "label": "Cooperative",
+      "description": "Collaborative evaluations involving multiple stakeholders, including the developing organization, external experts, affected communities, and regulatory bodies working together."
+    }
+  },
+  "additionalAspectsSection": {
+    "id": "C",
+    "title": "Additional Evaluation Aspects",
+    "description": "Document any other evaluation aspects for this category that may not have been captured by the structured questions above. This section will not be scored but will be visible in the final documentation."
+  },
+  "categoryHints": {
+    "language-communication": {
+      "benchmark": "Hint: mention benchmarks for language understanding/generation, prompt settings, multilingual splits, and whether factuality checks were performed.",
+      "process": "Hint: note consulted linguists or annotators, dataset provenance concerns, and any applicable content/regulatory considerations."
+    },
+    "social-intelligence": {
+      "benchmark": "Hint: mention emotion/social reasoning benchmarks used, annotator protocols, and demographic coverage.",
+      "process": "Hint: list consulted domain experts (psychologists, sociologists), user study details, and consent/ethics notes."
+    },
+    "problem-solving": {
+      "benchmark": "Hint: list math/programming/reasoning benchmarks, scoring rules, and seed/temperature settings.",
+      "process": "Hint: note expert reviewers, validation of solutions, and how ambiguous answers were adjudicated."
+    },
+    "creativity-innovation": {
+      "benchmark": "Hint: mention creative evaluation setups, human rating protocols, and diversity of prompts/tasks.",
+      "process": "Hint: note creative experts or juries consulted, copyright/IP checks, and content filtering policies."
+    },
+    "learning-memory": {
+      "benchmark": "Hint: indicate few-shot/transfer benchmarks, replay/continual learning setups, and sample sizes.",
+      "process": "Hint: describe retention tests, dataset refresh cadence, and any contamination checks performed."
+    },
+    "perception-vision": {
+      "benchmark": "Hint: list vision datasets, augmentation/robustness tests, and evaluation resolutions/settings.",
+      "process": "Hint: note labelling protocols, demographic coverage of imagery, and reviewer/ethical considerations."
+    },
+    "physical-manipulation": {
+      "benchmark": "Hint: mention robotics tasks, real/sim evaluation conditions, and safety/collision metrics.",
+      "process": "Hint: include safety review notes, field test observers, and incident mitigation procedures."
+    },
+    "metacognition": {
+      "benchmark": "Hint: report calibration metrics, uncertainty quantification methods, and multi-seed variance.",
+      "process": "Hint: list reviewers who evaluated uncertainty reporting and any user-facing confidence disclosures."
+    },
+    "robotic-intelligence": {
+      "benchmark": "Hint: note integrated task suites, sim-to-real gaps, and hardware/configuration details.",
+      "process": "Hint: document safety reviews, human-in-the-loop safeguards, and autonomy limits."
+    },
+    "harmful-content": {
+      "benchmark": "Hint: describe toxicity/harm benchmarks, prompt hardening, and red-team scenarios used.",
+      "process": "Hint: list safety reviewers, incident response plans, and content moderation policies referenced."
+    },
+    "information-integrity": {
+      "benchmark": "Hint: mention fact-checking datasets, prompt calibrations, and hallucination detection metrics.",
+      "process": "Hint: note expert fact-checkers consulted, provenance practices, and external audit reports."
+    },
+    "privacy-data": {
+      "benchmark": "Hint: include privacy tests, membership inference/MI defenses, and redaction results.",
+      "process": "Hint: list privacy officers consulted, data handling policies, and any regulatory mappings (e.g., GDPR)."
+    },
+    "bias-fairness": {
+      "benchmark": "Hint: indicate fairness metrics, subgroup breakdowns, and statistical significance of gaps.",
+      "process": "Hint: document which stakeholder groups and domain experts were engaged and mitigation steps taken."
+    },
+    "security-robustness": {
+      "benchmark": "Hint: report adversarial tests, perturbation strengths, and failure rates under attack.",
+      "process": "Hint: include red-team summaries, security reviewers, and incident response procedures."
+    },
+    "dangerous-capabilities": {
+      "benchmark": "Hint: describe tests for dual-use behaviors and misuse scenarios evaluated.",
+      "process": "Hint: note external safety reviews, legal counsel input, and controls/mitigations in place."
+    },
+    "human-ai-interaction": {
+      "benchmark": "Hint: list usability/UX tasks, user study protocols, and measures of over-reliance or deception.",
+      "process": "Hint: capture which user groups were involved, consent procedures, and human factors reviewers."
+    },
+    "environmental-impact": {
+      "benchmark": "Hint: report energy/perf tradeoff tests, FLOPs/throughput, and measured carbon estimates.",
+      "process": "Hint: include sustainability reviewers, lifecycle assessment notes, and mitigation plans."
+    },
+    "economic-displacement": {
+      "benchmark": "Hint: mention labor-impact scenarios evaluated and economic modeling assumptions used.",
+      "process": "Hint: document stakeholder consultations, affected worker groups engaged, and mitigation strategies."
+    },
+    "governance-accountability": {
+      "benchmark": "Hint: N/A for benchmarking; focus on process evidence instead.",
+      "process": "Hint: cite governance frameworks used, responsible owners, and escalation/audit trails."
+    },
+    "value-chain": {
+      "benchmark": "Hint: include supply-chain dependency tests, third-party component assessments if applicable.",
+      "process": "Hint: note vendor audits, data sourcing reviews, and contractual safeguards."
+    }
+  },
+  "categoryQuestionHints": {
+    "language-communication": {
+      "A1": { "benchmark": "List exact language benchmarks, dataset versions, prompt templates, split (train/val/test), and evaluation conditions." },
+      "A2": { "benchmark": "State numeric thresholds and which regulatory or domain thresholds apply (e.g., accuracy, FPR/FNR targets)." },
+      "A3": { "benchmark": "Provide side-by-side comparisons vs. baselines/SOTA, significance tests, and matched prompt/hyperparams." },
+      "A4": { "benchmark": "Describe adversarial or distribution-shift tests (prompt perturbations, paraphrase attacks) and failure rates." },
+      "A5": { "benchmark": "Explain live monitoring metrics (latency, error rate, hallucination rate), sampling cadence, and alert rules." },
+      "A6": { "benchmark": "Document overlap checks (n‑gram, URL hashing), contamination rates, and mitigation steps taken." },
+      "B1": { "process": "Define scope, claims being evaluated, success criteria (e.g., BLEU/F1 cutoffs), and evaluation hypotheses." },
+      "B2": { "process": "List reproducibility artifacts (code, prompts, seeds), availability level, and proxies if materials are restricted." },
+      "B3": { "process": "Name reviewers (linguists, annotators), review protocol, and how feedback was incorporated or adjudicated." },
+      "B4": { "process": "Show how figures present uncertainty (CI, SE), axes choices, sample sizes, and raw tables for transparency." },
+      "B5": { "process": "Reference any applicable standards (e.g., ISO, domain regs), mapping to practices, and noted gaps." },
+      "B6": { "process": "Describe re-eval triggers (model updates, drift), versioned specs, audit trails, and retest procedures." }
+    }
+  },
+  "recommendedBenchmarks": {
+    "language-communication": "e.g., MMLU, BBH, SuperGLUE",
+    "social-intelligence": "e.g., SocialIQA, EmoBench, PersonaChat (human-eval)",
+    "problem-solving": "e.g., GSM8K, MATH, HumanEval",
+    "creativity-innovation": "e.g., human preference studies, CREAM (human-eval)",
+    "learning-memory": "e.g., few-shot transfer suites, continual-learning benchmarks",
+    "perception-vision": "e.g., ImageNet, COCO, VQA",
+    "physical-manipulation": "e.g., RoboSuite, YCB benchmarks, real/sim task suites",
+    "metacognition": "e.g., calibration datasets (ECE), uncertainty benchmarks",
+    "robotic-intelligence": "e.g., Habitat, AI2-THOR, DARPA challenge tasks",
+    "harmful-content": "e.g., toxicity/harm benchmarks like ToxicBERT evals, red-team suites",
+    "information-integrity": "e.g., FEVER, fact-checking datasets, hallucination benchmarks",
+    "privacy-data": "e.g., membership-inference tests, MI challenge datasets",
+    "bias-fairness": "e.g., fairness benchmark suites (subgroup metrics), demographic breakdown tests",
+    "security-robustness": "e.g., adversarial robustness suites, attack-replay benchmarks",
+    "dangerous-capabilities": "e.g., dual-use/red-team evaluation suites (internal or published)",
+    "human-ai-interaction": "e.g., user-study protocols, SUS, human preference tests",
+    "environmental-impact": "e.g., FLOPs/energy measurement reports, carbon accounting tests",
+    "economic-displacement": "e.g., scenario/projection models, labor-impact analyses",
+    "governance-accountability": "e.g., audit logs, governance checklists (process evidence)",
+    "value-chain": "e.g., third-party audit reports, supply-chain assessments"
+  },
+  "recommendedMetrics": {
+    "language-communication": "e.g., accuracy, F1, BLEU, ROUGE, BERTScore",
+    "social-intelligence": "e.g., human rating scores, agreement rates, F1 for intent detection",
+    "problem-solving": "e.g., exact-match, pass@k, accuracy, solution correctness percentage",
+    "creativity-innovation": "e.g., human preference %, novelty/diversity scores",
+    "learning-memory": "e.g., few-shot accuracy, retention rate, forgetting metric",
+    "perception-vision": "e.g., mAP, IoU, top-1/top-5 accuracy",
+    "physical-manipulation": "e.g., success rate, collision rate, completion time",
+    "metacognition": "e.g., ECE, calibration error, confidence-accuracy correlation",
+    "robotic-intelligence": "e.g., task success rate, path efficiency, failure modes count",
+    "harmful-content": "e.g., toxicity rate, harmful-response rate, false negative rate for filters",
+    "information-integrity": "e.g., precision/recall of fact-checking, citation accuracy",
+    "privacy-data": "e.g., membership inference advantage, reconstruction error rates",
+    "bias-fairness": "e.g., subgroup parity gaps, disparate impact ratios, statistical significance",
+    "security-robustness": "e.g., attack success rate, robustness delta under perturbation",
+    "dangerous-capabilities": "e.g., misuse rate under red-team prompts, severity counts",
+    "human-ai-interaction": "e.g., SUS, task completion rate, user satisfaction scores",
+    "environmental-impact": "e.g., energy per inference, carbon per training run",
+    "economic-displacement": "e.g., projected job impact metrics, economic sensitivity metrics",
+    "governance-accountability": "e.g., audit coverage %, policy alignment scoring",
+    "value-chain": "e.g., vendor risk scores, dependency vulnerability counts"
+  },
+  "defaultHints": {
+    "benchmark": "Hint: include relevant benchmark settings, scoring rules, and notable limitations.",
+    "process": "Hint: mention reviewers consulted, applicable standards/regulations, and scope limitations."
+  }
+}

schema/output-schema.json

@@ -0,0 +1,79 @@
+{
+  "id": "string",
+  "systemName": "string",
+  "url": "string",
+  "provider": "string",
+  "version": "string",
+  "modelTag": "string",
+  "knowledgeCutoff": "YYYY-MM-DD",
+  "modelType": "foundational | fine-tuned | na",
+  "inputModalities": ["string"],
+  "outputModalities": ["string"],
+  "deploymentContexts": ["string"],
+  "evaluationDate": "YYYY-MM-DD",
+  "evaluator": "string",
+  "selectedCategories": [
+    "language-communication",
+    "problem-solving"
+  ],
+  "categoryEvaluations": {
+    "language-communication": {
+      "benchmarkAnswers": {
+        "A1": "yes",
+        "A2": "no",
+        "A3": "na",
+        "A4": "yes",
+        "A5": "no",
+        "A6": "yes"
+      },
+      "processAnswers": {
+        "B1": "yes",
+        "B2": "no",
+        "B3": "yes",
+        "B4": "no",
+        "B5": "yes",
+        "B6": "na"
+      },
+      "benchmarkSources": {
+        "A1": [
+          {
+            "id": "1",
+            "benchmarkName": "MMLU",
+            "version": "2023-05",
+            "taskVariants": "multiple choice",
+            "metrics": "accuracy",
+            "url": "https://example.org",
+            "description": "string",
+            "sourceType": "external",
+            "score": "86.4%",
+            "confidenceInterval": "95% CI [85,88]",
+            "customFields": {}
+          }
+        ]
+      },
+      "processSources": {
+        "B1": [
+          {
+            "id": "7",
+            "url": "https://example.org/doc",
+            "description": "string",
+            "sourceType": "internal",
+            "documentType": "Research Paper",
+            "title": "string",
+            "author": "string",
+            "organization": "string",
+            "date": "YYYY-MM-DD",
+            "customFields": {}
+          }
+        ]
+      },
+      "additionalAspects": "string",
+      "score": {
+        "benchmarkScore": 0,
+        "processScore": 0,
+        "totalScore": 0,
+        "status": "strong"
+      }
+    }
+  }
+}

schema/system-info-schema.json

@@ -0,0 +1,53 @@
+{
+  "systemInfo": {
+    "id": "string",
+    "systemName": "string",
+    "url": "string",
+    "provider": "string",
+    "version": "string",
+    "modelTag": "string",
+    "knowledgeCutoff": "YYYY-MM-DD",
+    "modelType": "foundational | fine-tuned | na",
+    "inputModalities": ["string"],
+    "outputModalities": ["string"],
+    "systemTypes": ["string"],
+    "deploymentContexts": ["string"],
+    "deploymentContext": "string",
+    "evaluationDate": "YYYY-MM-DD",
+    "evaluator": "string"
+  },
+  "formOptions": {
+    "systemTypes": [
+      "Text-to-Text (e.g., chatbots, language models)",
+      "Text-to-Image (e.g., image generation)",
+      "Image-to-Text (e.g., image captioning, OCR)",
+      "Image-to-Image (e.g., image editing, style transfer)",
+      "Audio/Speech (e.g., speech recognition, text-to-speech)",
+      "Video (e.g., video generation, analysis)",
+      "Multimodal",
+      "Robotic/Embodied AI",
+      "Other"
+    ],
+    "modalities": [
+      "Text",
+      "Image",
+      "Audio",
+      "Video",
+      "Tabular",
+      "Robotics/Action",
+      "Other"
+    ],
+    "deploymentContexts": [
+      "Research/Academic",
+      "Internal/Enterprise Use",
+      "Public/Consumer-Facing",
+      "High-Risk Applications",
+      "Other"
+    ],
+    "modelTypes": [
+      { "value": "foundational", "label": "Foundational Model" },
+      { "value": "fine-tuned", "label": "Fine-tuned Model" },
+      { "value": "na", "label": "Doesn't apply" }
+    ]
+  }
+}