diff --git a/.vscode/settings.json b/.vscode/settings.json
index eccb27945..9c0220518 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -39,5 +39,5 @@
   "tailwindCSS.experimental.configFile": "packages/web/src/global.css",
   "files.associations": {
     "*.css": "tailwindcss"
-  },
+  }
 }
diff --git a/packages/web/src/Routes.jsx b/packages/web/src/Routes.jsx
index 5f2f5b8b9..bf5d5fe4a 100644
--- a/packages/web/src/Routes.jsx
+++ b/packages/web/src/Routes.jsx
@@ -20,6 +20,8 @@ import { BASEPATH } from '@config/api.js';
 import ProtectedGuard from '@/components/auth/ProtectedGuard.jsx';
 import ProjectView from '@/components/project/ProjectView.jsx';
 import { CreateOrgPage } from '@/components/org/index.js';
+import MockIndex from '@/components/mock/MockIndex.jsx';
+import RobinsReconcileSectionBQuestionMock from '@/components/mock/RobinsReconcileSectionBQuestionMock.jsx';
 
 export default function AppRoutes() {
   return (
@@ -68,6 +70,13 @@ export default function AppRoutes() {
         {/* Local checklists (not org-scoped, work offline) */}
         <Route path='/checklist/*' component={LocalChecklistView} />
         <Route path='/checklist/:checklistId' component={LocalChecklistView} />
+
+        {/* Mock routes - public, visual-only wireframes */}
+        <Route path='/mock' component={MockIndex} />
+        <Route
+          path='/mock/robins-reconcile-section-b-question'
+          component={RobinsReconcileSectionBQuestionMock}
+        />
       </Route>
       <Route path='*' component={NotFoundPage} />
     </Router>
diff --git a/packages/web/src/components/checklist/ChecklistWithPdf.jsx b/packages/web/src/components/checklist/ChecklistWithPdf.jsx
index e1b24873d..323f4f3c7 100644
--- a/packages/web/src/components/checklist/ChecklistWithPdf.jsx
+++ b/packages/web/src/components/checklist/ChecklistWithPdf.jsx
@@ -24,6 +24,7 @@ export default function ChecklistWithPdf(props) {
   // props.selectedPdfId - currently selected PDF ID
   // props.onPdfSelect - handler for PDF selection change
   // props.getQuestionNote - function to get Y.Text for a question note
+  // props.getRobinsText - function to get Y.Text for a ROBINS-I free-text field
   // props.pdfUrl - optional PDF URL (for server-hosted PDFs)
 
   return (
@@ -44,6 +45,7 @@ export default function ChecklistWithPdf(props) {
           onUpdate={props.onUpdate}
           readOnly={props.readOnly}
           getQuestionNote={props.getQuestionNote}
+          getRobinsText={props.getRobinsText}
         />
 
         {/* Second panel: PDF Viewer */}
diff --git a/packages/web/src/components/checklist/ChecklistYjsWrapper.jsx b/packages/web/src/components/checklist/ChecklistYjsWrapper.jsx
index 49d8535a2..a123baca1 100644
--- a/packages/web/src/components/checklist/ChecklistYjsWrapper.jsx
+++ b/packages/web/src/components/checklist/ChecklistYjsWrapper.jsx
@@ -40,6 +40,7 @@ export default function ChecklistYjsWrapper() {
     getChecklistData,
     addPdfToStudy,
     getQuestionNote,
+    getRobinsText,
   } = useProject(params.projectId);
 
   // Set active project for action store
@@ -460,6 +461,9 @@ export default function ChecklistYjsWrapper() {
           getQuestionNote={questionKey =>
             getQuestionNote(params.studyId, params.checklistId, questionKey)
           }
+          getRobinsText={(sectionKey, fieldKey, questionKey) =>
+            getRobinsText(params.studyId, params.checklistId, sectionKey, fieldKey, questionKey)
+          }
         />
       </Show>
     </>
diff --git a/packages/web/src/components/checklist/GenericChecklist.jsx b/packages/web/src/components/checklist/GenericChecklist.jsx
index 4eadaf958..e2d527474 100644
--- a/packages/web/src/components/checklist/GenericChecklist.jsx
+++ b/packages/web/src/components/checklist/GenericChecklist.jsx
@@ -25,6 +25,7 @@ import { ROBINSIChecklist } from '@/components/checklist/ROBINSIChecklist/index.
  * @param {Function} props.onUpdate - Callback for checklist updates
  * @param {boolean} [props.readOnly] - Whether the checklist is read-only
  * @param {Function} [props.getQuestionNote] - Function to get Y.Text for a question note
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export default function GenericChecklist(props) {
   // Determine the checklist type from props or state
@@ -55,6 +56,7 @@ export default function GenericChecklist(props) {
           showComments={true}
           showLegend={true}
           readOnly={props.readOnly}
+          getRobinsText={props.getRobinsText}
         />
       </Show>
     </div>
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/DomainJudgement.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/DomainJudgement.jsx
index 77e30c52b..9b9d7aa7d 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/DomainJudgement.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/DomainJudgement.jsx
@@ -1,8 +1,10 @@
-import { For } from 'solid-js';
+import { For, Show } from 'solid-js';
 import { ROB_JUDGEMENTS, BIAS_DIRECTIONS, DOMAIN1_DIRECTIONS } from './checklist-map.js';
 
 /**
  * Domain judgement selector with risk of bias level and optional direction
+ * Supports auto-first mode: in auto mode, buttons are visually secondary and clicking switches to manual
+ *
  * @param {Object} props
  * @param {string} props.domainId - Unique domain identifier
  * @param {string} props.judgement - Current judgement value
@@ -12,11 +14,20 @@ import { ROB_JUDGEMENTS, BIAS_DIRECTIONS, DOMAIN1_DIRECTIONS } from './checklist
  * @param {boolean} [props.showDirection] - Whether to show direction selector
  * @param {boolean} [props.isDomain1] - Whether this is Domain 1 (uses limited direction options)
  * @param {boolean} [props.disabled] - Whether the selector is disabled
+ * @param {boolean} [props.isAutoMode] - Whether in auto mode (buttons are secondary, clicking switches to manual)
  */
 export function DomainJudgement(props) {
   const directionOptions = () => (props.isDomain1 ? DOMAIN1_DIRECTIONS : BIAS_DIRECTIONS);
 
-  const getJudgementColor = judgement => {
+  const getJudgementColor = (judgement, isSelected) => {
+    if (!isSelected) {
+      // Unselected state - slightly dimmed in auto mode
+      return props.isAutoMode ?
+          'border-gray-200 bg-gray-50 text-gray-500 hover:border-gray-300 hover:bg-white'
+        : 'border-gray-200 bg-white text-gray-600 hover:border-gray-300';
+    }
+
+    // Selected state
     switch (judgement) {
       case 'Low':
         return 'bg-green-100 border-green-400 text-green-800';
@@ -33,41 +44,42 @@ export function DomainJudgement(props) {
     }
   };
 
+  // Shorten long judgement labels for display
+  const getShortLabel = judgement => {
+    if (judgement === 'Low (except for concerns about uncontrolled confounding)') {
+      return 'Low (except confounding)';
+    }
+    return judgement;
+  };
+
   return (
-    <div class='mt-4 rounded-lg bg-gray-50 p-4'>
-      {/* Risk of bias judgement */}
-      <div class='mb-3'>
-        <div class='mb-2 text-sm font-medium text-gray-700'>Risk of bias judgement</div>
-        <div class='flex flex-wrap gap-2'>
-          <For each={ROB_JUDGEMENTS}>
-            {judgement => {
-              const isSelected = () => props.judgement === judgement;
-              return (
-                <button
-                  type='button'
-                  onClick={() => {
-                    if (props.disabled) return;
-                    // Toggle: deselect if already selected, otherwise select
-                    props.onJudgementChange(isSelected() ? null : judgement);
-                  }}
-                  disabled={props.disabled}
-                  class={`inline-flex items-center justify-center rounded-md border-2 px-3 py-1.5 text-sm font-medium transition-colors ${props.disabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'} ${
-                    isSelected() ?
-                      getJudgementColor(judgement)
-                    : 'border-gray-200 bg-white text-gray-600 hover:border-gray-300'
-                  } `}
-                >
-                  {judgement}
-                </button>
-              );
-            }}
-          </For>
-        </div>
+    <div>
+      {/* Risk of bias judgement buttons */}
+      <div class='flex flex-wrap gap-2'>
+        <For each={ROB_JUDGEMENTS}>
+          {judgement => {
+            const isSelected = () => props.judgement === judgement;
+            return (
+              <button
+                type='button'
+                onClick={() => {
+                  if (props.disabled) return;
+                  // In both modes: select the judgement (switches to manual via parent)
+                  props.onJudgementChange(isSelected() ? null : judgement);
+                }}
+                disabled={props.disabled}
+                class={`inline-flex items-center justify-center rounded-md border-2 px-3 py-1.5 text-sm font-medium transition-colors ${props.disabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'} ${getJudgementColor(judgement, isSelected())}`}
+              >
+                {getShortLabel(judgement)}
+              </button>
+            );
+          }}
+        </For>
       </div>
 
       {/* Direction of bias (optional) */}
-      {props.showDirection && (
-        <div>
+      <Show when={props.showDirection}>
+        <div class='mt-3'>
           <div class='mb-2 text-sm font-medium text-gray-700'>
             Predicted direction of bias
             <span class='ml-1 font-normal text-gray-400'>(optional)</span>
@@ -81,7 +93,6 @@ export function DomainJudgement(props) {
                     type='button'
                     onClick={() => {
                       if (props.disabled) return;
-                      // Toggle: deselect if already selected, otherwise select
                       props.onDirectionChange?.(isSelected() ? null : direction);
                     }}
                     disabled={props.disabled}
@@ -89,7 +100,7 @@ export function DomainJudgement(props) {
                       isSelected() ?
                         'border-blue-400 bg-blue-100 text-blue-800'
                       : 'border-gray-200 bg-white text-gray-500 hover:border-gray-300'
-                    } `}
+                    }`}
                   >
                     {direction}
                   </button>
@@ -98,7 +109,7 @@ export function DomainJudgement(props) {
             </For>
           </div>
         </div>
-      )}
+      </Show>
     </div>
   );
 }
@@ -125,9 +136,17 @@ export function JudgementBadge(props) {
     }
   };
 
+  // Shorten long judgement labels for badges
+  const getShortLabel = () => {
+    if (props.judgement === 'Low (except for concerns about uncontrolled confounding)') {
+      return 'Low (except confounding)';
+    }
+    return props.judgement || 'Not assessed';
+  };
+
   return (
     <span class={`inline-flex rounded px-2 py-0.5 text-xs font-medium ${getColor()}`}>
-      {props.judgement || 'Not assessed'}
+      {getShortLabel()}
     </span>
   );
 }
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/DomainSection.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/DomainSection.jsx
index 72f32ce37..0c2928317 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/DomainSection.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/DomainSection.jsx
@@ -1,39 +1,70 @@
-import { For, Show } from 'solid-js';
+import { For, Show, createMemo } from 'solid-js';
 import { ROBINS_I_CHECKLIST, getDomainQuestions } from './checklist-map.js';
 import { SignallingQuestion } from './SignallingQuestion.jsx';
 import { DomainJudgement, JudgementBadge } from './DomainJudgement.jsx';
+import { scoreRobinsDomain, getEffectiveDomainJudgement } from './scoring/robins-scoring.js';
 
 /**
  * A complete domain section with questions and judgement
+ * Now with auto-first scoring: calculated judgements are primary, manual override is explicit
+ *
  * @param {Object} props
  * @param {string} props.domainKey - The domain key (e.g., 'domain1a')
- * @param {Object} props.domainState - Current domain state { answers, judgement, direction }
+ * @param {Object} props.domainState - Current domain state { answers, judgement, judgementSource, direction }
  * @param {Function} props.onUpdate - Callback when domain state changes
  * @param {boolean} [props.disabled] - Whether the domain is disabled
  * @param {boolean} [props.showComments] - Whether to show comment fields
  * @param {boolean} [props.collapsed] - Whether the domain is collapsed
  * @param {Function} [props.onToggleCollapse] - Callback to toggle collapse
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function DomainSection(props) {
   const domain = () => ROBINS_I_CHECKLIST[props.domainKey];
   const questions = () => getDomainQuestions(props.domainKey);
   const hasSubsections = () => !!domain()?.subsections;
 
+  // Smart scoring: compute auto judgement from answers
+  const autoScore = createMemo(() => {
+    return scoreRobinsDomain(props.domainKey, props.domainState?.answers);
+  });
+
+  // Effective judgement: auto unless manually overridden
+  const effectiveJudgement = createMemo(() => {
+    return getEffectiveDomainJudgement(props.domainState, autoScore());
+  });
+
+  // Check if currently in manual mode (reactive)
+  const isManualMode = createMemo(() => props.domainState?.judgementSource === 'manual');
+
   function handleQuestionUpdate(questionKey, newAnswer) {
     const newAnswers = {
       ...props.domainState.answers,
       [questionKey]: newAnswer,
     };
-    props.onUpdate({
+
+    // Compute what the auto judgement would be with new answers
+    const newAutoScore = scoreRobinsDomain(props.domainKey, newAnswers);
+
+    // If in auto mode, sync judgement with calculated value
+    const currentSource = props.domainState?.judgementSource || 'auto';
+    const newState = {
       ...props.domainState,
       answers: newAnswers,
-    });
+    };
+
+    if (currentSource === 'auto' && newAutoScore.judgement) {
+      newState.judgement = newAutoScore.judgement;
+    }
+
+    props.onUpdate(newState);
   }
 
   function handleJudgementChange(judgement) {
+    // Clicking a judgement button switches to manual mode
     props.onUpdate({
       ...props.domainState,
       judgement,
+      judgementSource: 'manual',
     });
   }
 
@@ -44,6 +75,26 @@ export function DomainSection(props) {
     });
   }
 
+  function handleRevertToAuto() {
+    // Reset to auto mode with calculated judgement
+    const currentState = props.domainState || {};
+    props.onUpdate({
+      ...currentState,
+      judgement: autoScore().judgement,
+      judgementSource: 'auto',
+    });
+  }
+
+  function handleSwitchToManual() {
+    // Switch to manual mode but keep current judgement (or use current auto if no judgement set)
+    const currentState = props.domainState || {};
+    props.onUpdate({
+      ...currentState,
+      judgement: currentState.judgement || autoScore().judgement,
+      judgementSource: 'manual',
+    });
+  }
+
   // Get completion status
   const completionStatus = () => {
     const qs = questions();
@@ -75,9 +126,17 @@ export function DomainSection(props) {
             {completionStatus().answered}/{completionStatus().total}
           </span>
 
-          {/* Judgement badge if set */}
-          <Show when={props.domainState?.judgement}>
-            <JudgementBadge judgement={props.domainState.judgement} />
+          {/* Judgement badge with mode indicator */}
+          <Show when={effectiveJudgement()}>
+            <div class='flex items-center gap-1.5'>
+              <Show when={isManualMode()}>
+                <span class='text-xs text-amber-600'>Manual</span>
+              </Show>
+              <JudgementBadge judgement={effectiveJudgement()} />
+            </div>
+          </Show>
+          <Show when={!effectiveJudgement() && autoScore().isComplete === false}>
+            <span class='text-xs text-gray-400'>Incomplete</span>
           </Show>
 
           {/* Collapse indicator */}
@@ -113,6 +172,9 @@ export function DomainSection(props) {
                       onUpdate={newAnswer => handleQuestionUpdate(qKey, newAnswer)}
                       disabled={props.disabled}
                       showComment={props.showComments}
+                      domainKey={props.domainKey}
+                      questionKey={qKey}
+                      getRobinsText={props.getRobinsText}
                     />
                   )}
                 </For>
@@ -144,17 +206,73 @@ export function DomainSection(props) {
             </For>
           </Show>
 
-          {/* Domain judgement */}
-          <DomainJudgement
-            domainId={props.domainKey}
-            judgement={props.domainState?.judgement}
-            direction={props.domainState?.direction}
-            onJudgementChange={handleJudgementChange}
-            onDirectionChange={handleDirectionChange}
-            showDirection={domain()?.hasDirection}
-            isDomain1={props.domainKey === 'domain1a' || props.domainKey === 'domain1b'}
-            disabled={props.disabled}
-          />
+          {/* Auto-first judgement section */}
+          <div class='mt-4 rounded-lg bg-gray-50 p-4'>
+            {/* Calculated judgement display */}
+            <div class='mb-3 flex items-center justify-between'>
+              <div class='flex items-center gap-3'>
+                <span class='text-sm font-medium text-gray-700'>Risk of bias judgement</span>
+                <Show when={autoScore().judgement}>
+                  <div class='flex items-center gap-2 rounded-md bg-white px-2.5 py-1 text-xs shadow-sm'>
+                    <span class='text-gray-500'>Calculated:</span>
+                    <JudgementBadge judgement={autoScore().judgement} />
+                  </div>
+                </Show>
+                <Show when={!autoScore().judgement && !autoScore().isComplete}>
+                  <span class='text-xs text-gray-400'>(answer more questions)</span>
+                </Show>
+              </div>
+
+              {/* Mode toggle */}
+              <div class='flex items-center gap-2'>
+                <div class='flex rounded-md border border-gray-200 bg-white text-xs'>
+                  <button
+                    type='button'
+                    onClick={e => {
+                      e.stopPropagation();
+                      handleRevertToAuto();
+                    }}
+                    disabled={props.disabled}
+                    class={`rounded-l-md px-2.5 py-1 transition-colors ${
+                      !isManualMode() ?
+                        'bg-blue-100 text-blue-800'
+                      : 'text-gray-600 hover:bg-gray-50'
+                    } ${props.disabled ? 'cursor-not-allowed opacity-50' : ''}`}
+                  >
+                    Auto
+                  </button>
+                  <button
+                    type='button'
+                    onClick={e => {
+                      e.stopPropagation();
+                      handleSwitchToManual();
+                    }}
+                    disabled={props.disabled}
+                    class={`rounded-r-md border-l border-gray-200 px-2.5 py-1 transition-colors ${
+                      isManualMode() ?
+                        'bg-amber-100 text-amber-800'
+                      : 'text-gray-600 hover:bg-gray-50'
+                    } ${props.disabled ? 'cursor-not-allowed opacity-50' : ''}`}
+                  >
+                    Manual
+                  </button>
+                </div>
+              </div>
+            </div>
+
+            {/* Judgement selector - only fully interactive in manual mode */}
+            <DomainJudgement
+              domainId={props.domainKey}
+              judgement={effectiveJudgement()}
+              direction={props.domainState?.direction}
+              onJudgementChange={handleJudgementChange}
+              onDirectionChange={handleDirectionChange}
+              showDirection={domain()?.hasDirection}
+              isDomain1={props.domainKey === 'domain1a' || props.domainKey === 'domain1b'}
+              disabled={props.disabled}
+              isAutoMode={!isManualMode()}
+            />
+          </div>
         </div>
       </Show>
     </div>
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/OverallSection.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/OverallSection.jsx
index cad9b3043..8aa0ce3b0 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/OverallSection.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/OverallSection.jsx
@@ -1,23 +1,47 @@
-import { For } from 'solid-js';
+import { For, Show, createMemo } from 'solid-js';
 import { OVERALL_ROB_JUDGEMENTS, BIAS_DIRECTIONS } from './checklist-map.js';
-import { scoreChecklist } from './checklist.js';
+import { getSmartScoring, mapOverallJudgementToDisplay } from './checklist.js';
 
 /**
  * Overall risk of bias section with final judgement
+ * Now with auto-first scoring: calculated judgement is primary, manual override is explicit
+ *
  * @param {Object} props
- * @param {Object} props.overallState - Current overall state { judgement, direction }
+ * @param {Object} props.overallState - Current overall state { judgement, judgementSource, direction }
  * @param {Object} props.checklistState - Full checklist state (for auto-scoring)
  * @param {Function} props.onUpdate - Callback when overall state changes
  * @param {boolean} [props.disabled] - Whether the section is disabled
  */
 export function OverallSection(props) {
-  // Calculated score based on domains
-  const calculatedScore = () => scoreChecklist(props.checklistState);
+  // Smart scoring: compute auto judgement from all domains
+  const smartScoring = createMemo(() => getSmartScoring(props.checklistState));
+
+  // Calculated overall score (internal format)
+  const calculatedScore = () => smartScoring().overall;
+
+  // Calculated overall in display format (maps to OVERALL_ROB_JUDGEMENTS)
+  const calculatedDisplayJudgement = createMemo(() => {
+    const score = calculatedScore();
+    return mapOverallJudgementToDisplay(score);
+  });
+
+  // Check if currently in manual mode (reactive)
+  const isManualMode = createMemo(() => props.overallState?.judgementSource === 'manual');
+
+  // Effective judgement: what's actually shown/used
+  const effectiveJudgement = createMemo(() => {
+    if (isManualMode() && props.overallState?.judgement) {
+      return props.overallState.judgement;
+    }
+    return calculatedDisplayJudgement();
+  });
 
   function handleJudgementChange(judgement) {
+    // Clicking a judgement button switches to manual mode
     props.onUpdate({
       ...props.overallState,
       judgement,
+      judgementSource: 'manual',
     });
   }
 
@@ -28,83 +52,153 @@ export function OverallSection(props) {
     });
   }
 
-  const getJudgementColor = judgement => {
+  function handleRevertToAuto() {
+    // Reset to auto mode with calculated judgement
+    const currentState = props.overallState || {};
+    props.onUpdate({
+      ...currentState,
+      judgement: calculatedDisplayJudgement(),
+      judgementSource: 'auto',
+    });
+  }
+
+  function handleSwitchToManual() {
+    // Switch to manual mode but keep current judgement (or use current auto if no judgement set)
+    const currentState = props.overallState || {};
+    props.onUpdate({
+      ...currentState,
+      judgement: currentState.judgement || calculatedDisplayJudgement(),
+      judgementSource: 'manual',
+    });
+  }
+
+  const getJudgementColor = (judgement, isSelected) => {
+    if (!isSelected) {
+      return isManualMode() ?
+          'border-gray-200 bg-white text-gray-600 hover:border-gray-300'
+        : 'border-gray-200 bg-gray-50 text-gray-500 hover:border-gray-300 hover:bg-white';
+    }
+
     switch (judgement) {
       case 'Low risk of bias except for concerns about uncontrolled confounding':
-      case 'Low (except confounding)':
         return 'bg-green-100 border-green-400 text-green-800';
       case 'Moderate risk':
-      case 'Moderate':
         return 'bg-yellow-100 border-yellow-400 text-yellow-800';
       case 'Serious risk':
-      case 'Serious':
         return 'bg-orange-100 border-orange-400 text-orange-800';
       case 'Critical risk':
-      case 'Critical':
         return 'bg-red-100 border-red-400 text-red-800';
       default:
         return 'bg-gray-50 border-gray-200 text-gray-600';
     }
   };
 
-  const getScoreColor = score => {
+  const getScoreBadgeColor = score => {
     switch (score) {
       case 'Low':
-        return 'text-green-600';
+      case 'Low (except for concerns about uncontrolled confounding)':
+        return 'bg-green-100 text-green-800';
       case 'Moderate':
-        return 'text-yellow-600';
+        return 'bg-yellow-100 text-yellow-800';
       case 'Serious':
-        return 'text-orange-600';
+        return 'bg-orange-100 text-orange-800';
       case 'Critical':
-        return 'text-red-600';
+        return 'bg-red-100 text-red-800';
       default:
-        return 'text-gray-500';
+        return 'bg-gray-100 text-gray-600';
     }
   };
 
   return (
     <div class='overflow-hidden rounded-lg bg-white shadow-md'>
       <div class='bg-gray-800 px-6 py-4 text-white'>
-        <h3 class='text-lg font-semibold'>Overall Risk of Bias</h3>
-        <p class='mt-1 text-sm text-gray-300'>Final assessment based on all domain judgements</p>
+        <div class='flex items-center justify-between'>
+          <div>
+            <h3 class='text-lg font-semibold'>Overall Risk of Bias</h3>
+            <p class='mt-1 text-sm text-gray-300'>
+              Final assessment based on all domain judgements
+            </p>
+          </div>
+
+          {/* Overall calculated badge in header */}
+          <Show when={calculatedScore() && calculatedScore() !== 'Incomplete'}>
+            <div class='flex flex-col items-end gap-1'>
+              <span
+                class={`rounded-md px-3 py-1 text-sm font-semibold ${getScoreBadgeColor(calculatedScore())}`}
+              >
+                {calculatedScore()}
+              </span>
+              <Show when={isManualMode()}>
+                <span class='text-xs text-amber-300'>Manual override</span>
+              </Show>
+            </div>
+          </Show>
+          <Show when={calculatedScore() === 'Incomplete'}>
+            <span class='rounded-md bg-gray-600 px-3 py-1 text-sm text-gray-300'>Incomplete</span>
+          </Show>
+        </div>
       </div>
 
       <div class='px-6 py-5'>
-        {/* Calculated score hint */}
-        <div class='mb-4 rounded-lg bg-gray-50 p-3'>
-          <div class='text-sm text-gray-600'>
-            <span class='font-medium'>Calculated score: </span>
-            <span class={`font-semibold ${getScoreColor(calculatedScore())}`}>
-              {calculatedScore()}
-            </span>
+        {/* Calculated score display with mode toggle */}
+        <div class='mb-5 flex items-center justify-between rounded-lg bg-gray-50 p-4'>
+          <div class='flex items-center gap-3'>
+            <span class='text-sm font-medium text-gray-700'>Calculated judgement:</span>
+            <Show
+              when={calculatedDisplayJudgement()}
+              fallback={<span class='text-sm text-gray-400'>Complete all domains</span>}
+            >
+              <span
+                class={`rounded-md px-2.5 py-1 text-sm font-medium ${getScoreBadgeColor(calculatedScore())}`}
+              >
+                {calculatedDisplayJudgement()}
+              </span>
+            </Show>
+          </div>
+
+          {/* Mode toggle */}
+          <div class='flex items-center gap-2'>
+            <div class='flex rounded-md border border-gray-200 bg-white text-xs'>
+              <button
+                type='button'
+                onClick={handleRevertToAuto}
+                disabled={props.disabled}
+                class={`rounded-l-md px-2.5 py-1 transition-colors ${
+                  !isManualMode() ? 'bg-blue-100 text-blue-800' : 'text-gray-600 hover:bg-gray-50'
+                } ${props.disabled ? 'cursor-not-allowed opacity-50' : ''}`}
+              >
+                Auto
+              </button>
+              <button
+                type='button'
+                onClick={handleSwitchToManual}
+                disabled={props.disabled}
+                class={`rounded-r-md border-l border-gray-200 px-2.5 py-1 transition-colors ${
+                  isManualMode() ? 'bg-amber-100 text-amber-800' : 'text-gray-600 hover:bg-gray-50'
+                } ${props.disabled ? 'cursor-not-allowed opacity-50' : ''}`}
+              >
+                Manual
+              </button>
+            </div>
           </div>
-          <p class='mt-1 text-xs text-gray-400'>
-            Based on the highest risk of bias across all domains. You may override this judgement
-            below.
-          </p>
         </div>
 
-        {/* Overall risk of bias judgement */}
+        {/* Overall risk of bias judgement buttons */}
         <div class='mb-5'>
           <div class='mb-3 text-sm font-medium text-gray-700'>Overall risk of bias judgement</div>
           <div class='flex flex-wrap gap-2'>
             <For each={OVERALL_ROB_JUDGEMENTS}>
               {judgement => {
-                const isSelected = () => props.overallState?.judgement === judgement;
+                const isSelected = () => effectiveJudgement() === judgement;
                 return (
                   <button
                     type='button'
                     onClick={() => {
                       if (props.disabled) return;
-                      // Toggle: deselect if already selected, otherwise select
                       handleJudgementChange(isSelected() ? null : judgement);
                     }}
                     disabled={props.disabled}
-                    class={`inline-flex items-center justify-center rounded-lg border-2 px-4 py-2 text-sm font-medium transition-colors ${props.disabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'} ${
-                      isSelected() ?
-                        getJudgementColor(judgement)
-                      : 'border-gray-200 bg-white text-gray-600 hover:border-gray-300'
-                    } `}
+                    class={`inline-flex items-center justify-center rounded-lg border-2 px-4 py-2 text-sm font-medium transition-colors ${props.disabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'} ${getJudgementColor(judgement, isSelected())}`}
                   >
                     {judgement}
                   </button>
@@ -129,7 +223,6 @@ export function OverallSection(props) {
                     type='button'
                     onClick={() => {
                       if (props.disabled) return;
-                      // Toggle: deselect if already selected, otherwise select
                       handleDirectionChange(isSelected() ? null : direction);
                     }}
                     disabled={props.disabled}
@@ -137,7 +230,7 @@ export function OverallSection(props) {
                       isSelected() ?
                         'border-blue-400 bg-blue-100 text-blue-800'
                       : 'border-gray-200 bg-gray-50 text-gray-500 hover:border-gray-300'
-                    } `}
+                    }`}
                   >
                     {direction}
                   </button>
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/PlanningSection.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/PlanningSection.jsx
index 87efcd02a..9d8c5dfa7 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/PlanningSection.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/PlanningSection.jsx
@@ -1,4 +1,5 @@
 import { PLANNING_SECTION } from './checklist-map.js';
+import NoteEditor from '@/components/checklist/common/NoteEditor.jsx';
 
 /**
  * Planning Section: List confounding factors at planning stage
@@ -6,18 +7,15 @@ import { PLANNING_SECTION } from './checklist-map.js';
  * @param {Object} props.planningState - Current planning state { confoundingFactors }
  * @param {Function} props.onUpdate - Callback when planning state changes
  * @param {boolean} [props.disabled] - Whether the section is disabled
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function PlanningSection(props) {
   const p1Field = PLANNING_SECTION.p1;
 
-  function handleFieldChange(value) {
-    props.onUpdate({
-      ...props.planningState,
-      [p1Field.stateKey]: value,
-    });
-  }
-
-  const value = () => props.planningState?.[p1Field.stateKey] || '';
+  const yText = () => {
+    if (!props.getRobinsText) return null;
+    return props.getRobinsText('planning', 'confoundingFactors');
+  };
 
   return (
     <div class='overflow-hidden rounded-lg border border-gray-200 bg-white shadow-sm'>
@@ -33,14 +31,14 @@ export function PlanningSection(props) {
               <span class='font-medium'>{p1Field.label}.</span>
               <span class='ml-1'>{p1Field.text}</span>
             </span>
-            <textarea
-              value={value()}
-              disabled={props.disabled}
-              placeholder={p1Field.placeholder}
-              onInput={e => handleFieldChange(e.currentTarget.value)}
-              rows={4}
-              class={`mt-2 block w-full rounded-lg border border-gray-300 px-3 py-2 text-sm placeholder:text-gray-400 focus:border-transparent focus:ring-2 focus:ring-blue-500 focus:outline-none ${props.disabled ? 'cursor-not-allowed bg-gray-100 opacity-60' : 'bg-white'} `}
-            />
+            <div class='mt-2'>
+              <NoteEditor
+                yText={yText()}
+                placeholder={p1Field.placeholder}
+                readOnly={props.disabled}
+                inline={true}
+              />
+            </div>
           </label>
         </div>
       </div>
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/ROBINSIChecklist.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/ROBINSIChecklist.jsx
index ffe7fa3bb..ed3e232f7 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/ROBINSIChecklist.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/ROBINSIChecklist.jsx
@@ -9,6 +9,7 @@ import { SectionD } from './SectionD.jsx';
 import { DomainSection } from './DomainSection.jsx';
 import { OverallSection } from './OverallSection.jsx';
 import { ResponseLegend } from './SignallingQuestion.jsx';
+import { ScoringSummary } from './ScoringSummary.jsx';
 
 /**
  * Main ROBINS-I V2 Checklist Component
@@ -19,6 +20,7 @@ import { ResponseLegend } from './SignallingQuestion.jsx';
  * @param {boolean} [props.showComments] - Whether to show comment fields for each question
  * @param {boolean} [props.showLegend] - Whether to show the response legend
  * @param {boolean} [props.readOnly] - Whether the checklist is read-only (disables all inputs)
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function ROBINSIChecklist(props) {
   const isReadOnly = () => !!props.readOnly;
@@ -70,12 +72,38 @@ export function ROBINSIChecklist(props) {
     }));
   }
 
+  // Handle domain chip click from summary - expand and scroll to domain
+  function handleDomainClick(domainKey) {
+    // Expand the domain if collapsed
+    setCollapsedDomains(prev => ({
+      ...prev,
+      [domainKey]: false,
+    }));
+
+    // Scroll to domain section after a short delay for DOM update
+    setTimeout(() => {
+      const element = document.getElementById(`domain-section-${domainKey}`);
+      element?.scrollIntoView({ behavior: 'smooth', block: 'start' });
+    }, 100);
+  }
+
   return (
     <div class='bg-blue-50'>
       <div class='container mx-auto max-w-5xl space-y-4 px-4 py-6'>
         <div class='mb-6 text-left text-lg font-semibold text-gray-900 sm:text-center'>
           {props.checklistState.name || 'ROBINS-I Checklist'}
         </div>
+
+        {/* Scoring Summary Strip - shows overall + domain status */}
+        <Show when={!stopAssessment()}>
+          <div class='sticky z-40' style={{ top: '8px' }}>
+            <ScoringSummary
+              checklistState={props.checklistState}
+              onDomainClick={handleDomainClick}
+            />
+          </div>
+        </Show>
+
         {/* Response Legend */}
         <Show when={props.showLegend !== false}>
           <ResponseLegend />
@@ -86,6 +114,7 @@ export function ROBINSIChecklist(props) {
           planningState={props.checklistState?.planning}
           onUpdate={handlePlanningUpdate}
           disabled={isReadOnly()}
+          getRobinsText={props.getRobinsText}
         />
 
         {/* Preliminary Considerations Header */}
@@ -100,6 +129,7 @@ export function ROBINSIChecklist(props) {
           sectionAState={props.checklistState?.sectionA}
           onUpdate={handleSectionAUpdate}
           disabled={isReadOnly()}
+          getRobinsText={props.getRobinsText}
         />
 
         {/* Section B: Proceed with assessment */}
@@ -107,6 +137,7 @@ export function ROBINSIChecklist(props) {
           sectionBState={props.checklistState?.sectionB}
           onUpdate={handleSectionBUpdate}
           disabled={isReadOnly()}
+          getRobinsText={props.getRobinsText}
         />
 
         {/* Section C: Target randomized trial */}
@@ -114,6 +145,7 @@ export function ROBINSIChecklist(props) {
           sectionCState={props.checklistState?.sectionC}
           onUpdate={handleSectionCUpdate}
           disabled={isReadOnly()}
+          getRobinsText={props.getRobinsText}
         />
 
         {/* Section D: Information sources */}
@@ -121,6 +153,7 @@ export function ROBINSIChecklist(props) {
           sectionDState={props.checklistState?.sectionD}
           onUpdate={handleSectionDUpdate}
           disabled={isReadOnly()}
+          getRobinsText={props.getRobinsText}
         />
 
         {/* Domain sections - hidden entirely if assessment should stop */}
@@ -128,15 +161,24 @@ export function ROBINSIChecklist(props) {
           <div class='space-y-4'>
             <For each={activeDomains()}>
               {domainKey => (
-                <DomainSection
-                  domainKey={domainKey}
-                  domainState={props.checklistState?.[domainKey]}
-                  onUpdate={newState => handleDomainUpdate(domainKey, newState)}
-                  disabled={isReadOnly()}
-                  showComments={props.showComments}
-                  collapsed={collapsedDomains()[domainKey]}
-                  onToggleCollapse={() => toggleDomainCollapse(domainKey)}
-                />
+                <div
+                  id={`domain-section-${domainKey}`}
+                  style={{
+                    'scroll-margin-top':
+                      'calc(var(--app-navbar-height, 56px) + var(--robins-summary-height, 0px) + 8px)',
+                  }}
+                >
+                  <DomainSection
+                    domainKey={domainKey}
+                    domainState={props.checklistState?.[domainKey]}
+                    onUpdate={newState => handleDomainUpdate(domainKey, newState)}
+                    disabled={isReadOnly()}
+                    showComments={props.showComments}
+                    collapsed={collapsedDomains()[domainKey]}
+                    onToggleCollapse={() => toggleDomainCollapse(domainKey)}
+                    getRobinsText={props.getRobinsText}
+                  />
+                </div>
               )}
             </For>
           </div>
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/ScoringSummary.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/ScoringSummary.jsx
new file mode 100644
index 000000000..e2047f841
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/ScoringSummary.jsx
@@ -0,0 +1,265 @@
+import { For, Show, createMemo, createSignal } from 'solid-js';
+import { ROBINS_I_CHECKLIST, getActiveDomainKeys } from './checklist-map.js';
+import { getSmartScoring } from './checklist.js';
+import { Dialog } from '@corates/ui';
+import { FiExternalLink, FiInfo } from 'solid-icons/fi';
+
+/**
+ * Compact scoring summary strip for ROBINS-I checklist
+ * Shows overall calculated judgement and domain status chips
+ *
+ * @param {Object} props
+ * @param {Object} props.checklistState - Full checklist state
+ * @param {Function} [props.onDomainClick] - Callback when a domain chip is clicked (to expand/navigate)
+ */
+export function ScoringSummary(props) {
+  const [resourcesOpen, setResourcesOpen] = createSignal(false);
+
+  const smartScoring = createMemo(() => getSmartScoring(props.checklistState));
+
+  const isPerProtocol = () => props.checklistState?.sectionC?.isPerProtocol || false;
+  const activeDomains = createMemo(() => getActiveDomainKeys(isPerProtocol()));
+
+  // Count complete domains
+  const domainStats = createMemo(() => {
+    const scoring = smartScoring();
+    let complete = 0;
+    let total = activeDomains().length;
+
+    activeDomains().forEach(domainKey => {
+      const domainInfo = scoring.domains[domainKey];
+      if (domainInfo?.effective) {
+        complete++;
+      }
+    });
+
+    return { complete, total };
+  });
+
+  const getOverallColor = () => {
+    const overall = smartScoring().overall;
+    switch (overall) {
+      case 'Low':
+      case 'Low (except for concerns about uncontrolled confounding)':
+        return 'bg-green-500';
+      case 'Moderate':
+        return 'bg-yellow-500';
+      case 'Serious':
+        return 'bg-orange-500';
+      case 'Critical':
+        return 'bg-red-500';
+      default:
+        return 'bg-gray-400';
+    }
+  };
+
+  const getDomainChipColor = domainKey => {
+    const domainInfo = smartScoring().domains[domainKey];
+    if (!domainInfo?.effective) {
+      return 'bg-gray-100 text-gray-500 border-gray-200';
+    }
+
+    const judgement = domainInfo.effective;
+    const isManual = domainInfo.source === 'manual';
+
+    let baseColor;
+    switch (judgement) {
+      case 'Low':
+      case 'Low (except for concerns about uncontrolled confounding)':
+        baseColor = 'bg-green-100 text-green-800 border-green-300';
+        break;
+      case 'Moderate':
+        baseColor = 'bg-yellow-100 text-yellow-800 border-yellow-300';
+        break;
+      case 'Serious':
+        baseColor = 'bg-orange-100 text-orange-800 border-orange-300';
+        break;
+      case 'Critical':
+        baseColor = 'bg-red-100 text-red-800 border-red-300';
+        break;
+      default:
+        baseColor = 'bg-gray-100 text-gray-600 border-gray-300';
+    }
+
+    // Add ring for manual override
+    if (isManual && domainInfo.isOverridden) {
+      return `${baseColor} ring-2 ring-amber-400 ring-offset-1`;
+    }
+
+    return baseColor;
+  };
+
+  const getDomainShortName = domainKey => {
+    switch (domainKey) {
+      case 'domain1a':
+        return 'D1';
+      case 'domain1b':
+        return 'D1';
+      case 'domain2':
+        return 'D2';
+      case 'domain3':
+        return 'D3';
+      case 'domain4':
+        return 'D4';
+      case 'domain5':
+        return 'D5';
+      case 'domain6':
+        return 'D6';
+      default:
+        return domainKey;
+    }
+  };
+
+  const getDomainStatusText = domainKey => {
+    const domainInfo = smartScoring().domains[domainKey];
+    if (!domainInfo?.effective) {
+      return 'Incomplete';
+    }
+
+    const judgement = domainInfo.effective;
+    const shortJudgement =
+      judgement === 'Low (except for concerns about uncontrolled confounding)' ? 'Low*' : judgement;
+
+    if (domainInfo.source === 'manual' && domainInfo.isOverridden) {
+      return `${shortJudgement} (manual)`;
+    }
+
+    return shortJudgement;
+  };
+
+  return (
+    <div class='rounded-lg border border-gray-200 bg-white p-4 shadow-sm'>
+      <div class='flex flex-wrap items-center justify-between gap-4'>
+        {/* Overall score section */}
+        <div class='flex items-center gap-3'>
+          <div class='flex items-center gap-2'>
+            <div class={`h-3 w-3 rounded-full ${getOverallColor()}`} />
+            <span class='text-sm font-medium text-gray-700'>Overall:</span>
+            <span class='text-sm font-semibold text-gray-900'>
+              {smartScoring().overall || 'Incomplete'}
+            </span>
+          </div>
+          <span class='text-xs text-gray-400'>|</span>
+          <span class='text-xs text-gray-500'>
+            {domainStats().complete}/{domainStats().total} domains
+          </span>
+        </div>
+
+        {/* Domain chips */}
+        <div class='flex flex-wrap items-center gap-2'>
+          <For each={activeDomains()}>
+            {domainKey => (
+              <button
+                type='button'
+                onClick={() => props.onDomainClick?.(domainKey)}
+                title={`${ROBINS_I_CHECKLIST[domainKey]?.name}: ${getDomainStatusText(domainKey)}`}
+                class={`inline-flex items-center gap-1 rounded border px-2 py-0.5 text-xs font-medium transition-colors hover:opacity-80 ${getDomainChipColor(domainKey)}`}
+              >
+                <span>{getDomainShortName(domainKey)}</span>
+                <Show when={smartScoring().domains[domainKey]?.source === 'manual'}>
+                  <span class='text-amber-600'>*</span>
+                </Show>
+              </button>
+            )}
+          </For>
+
+          {/* Resources button */}
+          <button
+            type='button'
+            onClick={() => setResourcesOpen(true)}
+            class='ml-2 inline-flex items-center gap-1 rounded border border-blue-200 bg-blue-50 px-2 py-0.5 text-xs font-medium text-blue-700 transition-colors hover:bg-blue-100'
+          >
+            <FiInfo size={12} />
+            Resources
+          </button>
+        </div>
+      </div>
+
+      {/* Resources Dialog */}
+      <ResourcesDialog open={resourcesOpen()} onClose={() => setResourcesOpen(false)} />
+    </div>
+  );
+}
+
+/**
+ * Resources dialog with links to ROBINS-I guidance
+ */
+function ResourcesDialog(props) {
+  return (
+    <Dialog open={props.open} onOpenChange={open => !open && props.onClose()}>
+      <Dialog.Backdrop class='fixed inset-0 z-40 bg-black/50' />
+      <Dialog.Positioner class='fixed inset-0 z-50 flex items-center justify-center p-4'>
+        <Dialog.Content class='max-h-[85vh] w-full max-w-md overflow-auto rounded-lg bg-white shadow-xl'>
+          <div class='border-b border-gray-200 px-6 py-4'>
+            <Dialog.Title class='text-lg font-semibold text-gray-900'>
+              ROBINS-I V2 Resources
+            </Dialog.Title>
+            <Dialog.Description class='mt-1 text-sm text-gray-500'>
+              Official guidance and documentation for the ROBINS-I assessment tool.
+            </Dialog.Description>
+          </div>
+
+          <div class='space-y-4 px-6 py-4'>
+            <ResourceLink
+              title='ROBINS-I Tool (Official)'
+              description='Risk Of Bias In Non-randomized Studies of Interventions'
+              url='https://www.riskofbias.info/welcome/home/current-version-of-robins-i'
+            />
+
+            <ResourceLink
+              title='Detailed Guidance Document'
+              description='Comprehensive guidance for making judgements'
+              url='https://www.riskofbias.info/welcome/home/current-version-of-robins-i/robins-i-detailed-guidance-2016'
+            />
+
+            <ResourceLink
+              title='Cochrane Handbook Chapter'
+              description='Chapter 25: Assessing risk of bias in non-randomized studies'
+              url='https://training.cochrane.org/handbook/current/chapter-25'
+            />
+
+            <div class='rounded-lg bg-gray-50 p-3'>
+              <h4 class='text-sm font-medium text-gray-700'>About Auto Scoring</h4>
+              <p class='mt-1 text-xs text-gray-600'>
+                This tool automatically calculates domain judgements based on your signalling
+                question responses, following the official ROBINS-I decision algorithms. You can
+                override any automatic judgement if needed.
+              </p>
+            </div>
+          </div>
+
+          <div class='border-t border-gray-200 px-6 py-3'>
+            <button
+              type='button'
+              onClick={() => props.onClose()}
+              class='w-full rounded-lg bg-gray-100 px-4 py-2 text-sm font-medium text-gray-700 transition-colors hover:bg-gray-200'
+            >
+              Close
+            </button>
+          </div>
+        </Dialog.Content>
+      </Dialog.Positioner>
+    </Dialog>
+  );
+}
+
+function ResourceLink(props) {
+  return (
+    <a
+      href={props.url}
+      target='_blank'
+      rel='noopener noreferrer'
+      class='block rounded-lg border border-gray-200 p-3 transition-colors hover:border-blue-300 hover:bg-blue-50'
+    >
+      <div class='flex items-start justify-between gap-2'>
+        <div>
+          <h4 class='text-sm font-medium text-gray-900'>{props.title}</h4>
+          <p class='mt-0.5 text-xs text-gray-500'>{props.description}</p>
+        </div>
+        <FiExternalLink class='mt-0.5 shrink-0 text-gray-400' size={14} />
+      </div>
+    </a>
+  );
+}
+
+export default ScoringSummary;
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/SectionA.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/SectionA.jsx
index 2154b2b27..dabc287e5 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/SectionA.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/SectionA.jsx
@@ -1,5 +1,6 @@
 import { For, Show } from 'solid-js';
 import { SECTION_A } from './checklist-map.js';
+import NoteEditor from '@/components/checklist/common/NoteEditor.jsx';
 
 /**
  * Section A: Specify the result being assessed for risk of bias
@@ -7,15 +8,9 @@ import { SECTION_A } from './checklist-map.js';
  * @param {Object} props.sectionAState - Current section A state { numericalResult, furtherDetails, outcome }
  * @param {Function} props.onUpdate - Callback when section A state changes
  * @param {boolean} [props.disabled] - Whether the section is disabled
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function SectionA(props) {
-  function handleFieldChange(stateKey, value) {
-    props.onUpdate({
-      ...props.sectionAState,
-      [stateKey]: value,
-    });
-  }
-
   return (
     <div class='overflow-hidden rounded-lg border border-gray-200 bg-white shadow-sm'>
       <div class='border-b border-gray-200 bg-gray-50 px-6 py-4'>
@@ -30,7 +25,10 @@ export function SectionA(props) {
       <div class='space-y-4 px-6 py-4'>
         <For each={Object.entries(SECTION_A)}>
           {([_key, field]) => {
-            const value = () => props.sectionAState?.[field.stateKey] || '';
+            const yText = () => {
+              if (!props.getRobinsText) return null;
+              return props.getRobinsText('sectionA', field.stateKey);
+            };
 
             return (
               <div class='space-y-2'>
@@ -42,14 +40,14 @@ export function SectionA(props) {
                       <span class='ml-1 text-gray-400'>[optional]</span>
                     </Show>
                   </span>
-                  <textarea
-                    value={value()}
-                    disabled={props.disabled}
-                    placeholder={field.placeholder}
-                    onInput={e => handleFieldChange(field.stateKey, e.currentTarget.value)}
-                    rows={3}
-                    class={`mt-2 block w-full rounded-lg border border-gray-300 px-3 py-2 text-sm placeholder:text-gray-400 focus:border-transparent focus:ring-2 focus:ring-blue-500 focus:outline-none ${props.disabled ? 'cursor-not-allowed bg-gray-100 opacity-60' : 'bg-white'} `}
-                  />
+                  <div class='mt-2'>
+                    <NoteEditor
+                      yText={yText()}
+                      placeholder={field.placeholder}
+                      readOnly={props.disabled}
+                      inline={true}
+                    />
+                  </div>
                 </label>
               </div>
             );
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/SectionB.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/SectionB.jsx
index 24df27ddb..a1129e60f 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/SectionB.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/SectionB.jsx
@@ -2,6 +2,7 @@ import { For, Show, createMemo, createUniqueId } from 'solid-js';
 import { SECTION_B, RESPONSE_LABELS } from './checklist-map.js';
 import { shouldStopAssessment } from './checklist.js';
 import { FiAlertCircle } from 'solid-icons/fi';
+import NoteEditor from '@/components/checklist/common/NoteEditor.jsx';
 
 /**
  * Section B: Decide whether to proceed with risk-of-bias assessment
@@ -9,6 +10,7 @@ import { FiAlertCircle } from 'solid-icons/fi';
  * @param {Object} props.sectionBState - Current section B state
  * @param {Function} props.onUpdate - Callback when section B state changes
  * @param {boolean} [props.disabled] - Whether the section is disabled
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function SectionB(props) {
   const uniqueId = createUniqueId();
@@ -27,16 +29,6 @@ export function SectionB(props) {
     props.onUpdate(newState);
   }
 
-  function handleCommentChange(questionKey, value) {
-    props.onUpdate({
-      ...props.sectionBState,
-      [questionKey]: {
-        ...props.sectionBState[questionKey],
-        comment: value,
-      },
-    });
-  }
-
   const responseOptions = ['Y', 'PY', 'PN', 'N'];
 
   return (
@@ -96,14 +88,16 @@ export function SectionB(props) {
                 </div>
 
                 {/* Comment field */}
-                <input
-                  type='text'
-                  placeholder='Comment (optional)'
-                  value={props.sectionBState?.[key]?.comment || ''}
-                  onInput={e => handleCommentChange(key, e.target.value)}
-                  disabled={props.disabled}
-                  class='w-full rounded-lg border border-gray-300 py-2 pr-3 pl-3 text-xs transition focus:border-transparent focus:ring-2 focus:ring-blue-500 focus:outline-none disabled:bg-gray-50 disabled:text-gray-500 sm:text-sm'
-                />
+                <div class='mt-2'>
+                  <NoteEditor
+                    yText={
+                      props.getRobinsText ? props.getRobinsText('sectionB', 'comment', key) : null
+                    }
+                    placeholder='Comment (optional)'
+                    readOnly={props.disabled}
+                    inline={true}
+                  />
+                </div>
               </div>
             </div>
           )}
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/SectionC.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/SectionC.jsx
index cb01a8403..aab7f54f6 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/SectionC.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/SectionC.jsx
@@ -1,5 +1,6 @@
 import { For } from 'solid-js';
 import { SECTION_C } from './checklist-map.js';
+import NoteEditor from '@/components/checklist/common/NoteEditor.jsx';
 
 /**
  * Section C: Specify the (hypothetical) target randomized trial specific to the study
@@ -7,6 +8,7 @@ import { SECTION_C } from './checklist-map.js';
  * @param {Object} props.sectionCState - Current section C state { participants, interventionStrategy, comparatorStrategy, isPerProtocol }
  * @param {Function} props.onUpdate - Callback when section C state changes
  * @param {boolean} [props.disabled] - Whether the section is disabled
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function SectionC(props) {
   // Get textarea fields (C1, C2, C3) - exclude C4 which is handled separately
@@ -15,13 +17,6 @@ export function SectionC(props) {
 
   const c4Field = () => SECTION_C.c4;
 
-  function handleFieldChange(stateKey, value) {
-    props.onUpdate({
-      ...props.sectionCState,
-      [stateKey]: value,
-    });
-  }
-
   function handleProtocolToggle(value) {
     props.onUpdate({
       ...props.sectionCState,
@@ -42,7 +37,10 @@ export function SectionC(props) {
         {/* Text fields: C1, C2, C3 */}
         <For each={textFields()}>
           {([_key, field]) => {
-            const value = () => props.sectionCState?.[field.stateKey] || '';
+            const yText = () => {
+              if (!props.getRobinsText) return null;
+              return props.getRobinsText('sectionC', field.stateKey);
+            };
 
             return (
               <div class='space-y-2'>
@@ -51,14 +49,14 @@ export function SectionC(props) {
                     <span class='font-medium'>{field.label}.</span>
                     <span class='ml-1'>{field.text}</span>
                   </span>
-                  <textarea
-                    value={value()}
-                    disabled={props.disabled}
-                    placeholder={field.placeholder}
-                    onInput={e => handleFieldChange(field.stateKey, e.currentTarget.value)}
-                    rows={3}
-                    class={`mt-2 block w-full rounded-lg border border-gray-300 px-3 py-2 text-sm placeholder:text-gray-400 focus:border-transparent focus:ring-2 focus:ring-blue-500 focus:outline-none ${props.disabled ? 'cursor-not-allowed bg-gray-100 opacity-60' : 'bg-white'} `}
-                  />
+                  <div class='mt-2'>
+                    <NoteEditor
+                      yText={yText()}
+                      placeholder={field.placeholder}
+                      readOnly={props.disabled}
+                      inline={true}
+                    />
+                  </div>
                 </label>
               </div>
             );
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/SectionD.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/SectionD.jsx
index 66ed76a0f..2fb3ab0e3 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/SectionD.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/SectionD.jsx
@@ -1,5 +1,6 @@
 import { For } from 'solid-js';
 import { INFORMATION_SOURCES, SECTION_D } from './checklist-map.js';
+import NoteEditor from '@/components/checklist/common/NoteEditor.jsx';
 
 /**
  * Section D: Information sources
@@ -7,6 +8,7 @@ import { INFORMATION_SOURCES, SECTION_D } from './checklist-map.js';
  * @param {Object} props.sectionDState - Current section D state { sources: { [sourceName]: boolean }, otherSpecify: string }
  * @param {Function} props.onUpdate - Callback when section D state changes
  * @param {boolean} [props.disabled] - Whether the section is disabled
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function SectionD(props) {
   function handleSourceToggle(sourceName) {
@@ -20,15 +22,13 @@ export function SectionD(props) {
     });
   }
 
-  function handleOtherChange(value) {
-    props.onUpdate({
-      ...props.sectionDState,
-      otherSpecify: value,
-    });
-  }
-
   const isSourceChecked = sourceName => props.sectionDState?.sources?.[sourceName] || false;
 
+  const otherSpecifyYText = () => {
+    if (!props.getRobinsText) return null;
+    return props.getRobinsText('sectionD', 'otherSpecify');
+  };
+
   return (
     <div class='overflow-hidden rounded-lg border border-gray-200 bg-white shadow-sm'>
       <div class='border-b border-gray-200 bg-gray-50 px-6 py-4'>
@@ -61,14 +61,14 @@ export function SectionD(props) {
         <div class='border-t border-gray-200 pt-3'>
           <label class='block'>
             <span class='text-sm font-medium text-gray-700'>{SECTION_D.otherField.label}</span>
-            <textarea
-              value={props.sectionDState?.otherSpecify || ''}
-              disabled={props.disabled}
-              placeholder={SECTION_D.otherField.placeholder}
-              onInput={e => handleOtherChange(e.currentTarget.value)}
-              rows={2}
-              class={`mt-2 block w-full rounded-lg border border-gray-300 px-3 py-2 text-sm placeholder:text-gray-400 focus:border-transparent focus:ring-2 focus:ring-blue-500 focus:outline-none ${props.disabled ? 'cursor-not-allowed bg-gray-100 opacity-60' : 'bg-white'} `}
-            />
+            <div class='mt-2'>
+              <NoteEditor
+                yText={otherSpecifyYText()}
+                placeholder={SECTION_D.otherField.placeholder}
+                readOnly={props.disabled}
+                inline={true}
+              />
+            </div>
           </label>
         </div>
       </div>
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/SignallingQuestion.jsx b/packages/web/src/components/checklist/ROBINSIChecklist/SignallingQuestion.jsx
index 4c3a9a153..23cb72fec 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/SignallingQuestion.jsx
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/SignallingQuestion.jsx
@@ -1,5 +1,6 @@
-import { For, createUniqueId } from 'solid-js';
+import { For, createEffect, createUniqueId } from 'solid-js';
 import { RESPONSE_LABELS, getResponseOptions } from './checklist-map.js';
+import NoteEditor from '@/components/checklist/common/NoteEditor.jsx';
 
 /**
  * A single signalling question with radio button options
@@ -9,11 +10,25 @@ import { RESPONSE_LABELS, getResponseOptions } from './checklist-map.js';
  * @param {Function} props.onUpdate - Callback when answer changes
  * @param {boolean} [props.disabled] - Whether the question is disabled
  * @param {boolean} [props.showComment] - Whether to show comment field
+ * @param {string} [props.domainKey] - Domain key (e.g., 'domain1a') for comment Y.Text lookup
+ * @param {string} [props.questionKey] - Question key for comment Y.Text lookup
+ * @param {Function} [props.getRobinsText] - Function to get Y.Text for a ROBINS-I free-text field
  */
 export function SignallingQuestion(props) {
   const uniqueId = createUniqueId();
   const options = () => getResponseOptions(props.question.responseType);
 
+  createEffect(() => {
+    if (props.answer?.answer === 'NA') {
+      // Legacy answer value; NA is not a valid option for ROBINS-I in CoRATES.
+      // We coerce it to NI so the UI remains consistent and scoring doesn't get stuck.
+      props.onUpdate({
+        ...props.answer,
+        answer: 'NI',
+      });
+    }
+  });
+
   function handleAnswerChange(value) {
     props.onUpdate({
       ...props.answer,
@@ -21,12 +36,12 @@ export function SignallingQuestion(props) {
     });
   }
 
-  function handleCommentChange(e) {
-    props.onUpdate({
-      ...props.answer,
-      comment: e.target.value,
-    });
-  }
+  const commentYText = () => {
+    if (!props.showComment || !props.getRobinsText || !props.domainKey || !props.questionKey) {
+      return null;
+    }
+    return props.getRobinsText(props.domainKey, 'comment', props.questionKey);
+  };
 
   return (
     <div class='border-b border-gray-100 py-3 last:border-b-0'>
@@ -70,13 +85,11 @@ export function SignallingQuestion(props) {
       {/* Comment field (optional) */}
       {props.showComment && (
         <div class='mt-2'>
-          <input
-            type='text'
+          <NoteEditor
+            yText={commentYText()}
             placeholder='Comment (optional)'
-            value={props.answer?.comment || ''}
-            onInput={handleCommentChange}
-            disabled={props.disabled}
-            class='w-full rounded border border-gray-200 px-2 py-1 text-xs focus:border-transparent focus:ring-2 focus:ring-blue-500 focus:outline-none'
+            readOnly={props.disabled}
+            inline={true}
           />
         </div>
       )}
@@ -88,7 +101,7 @@ export function SignallingQuestion(props) {
  * Response legend component showing what each abbreviation means
  */
 export function ResponseLegend() {
-  const commonResponses = ['Y', 'PY', 'PN', 'N', 'NI', 'NA', 'WN', 'SN', 'SY', 'WY'];
+  const commonResponses = ['Y', 'PY', 'PN', 'N', 'NI', 'WN', 'SN', 'SY', 'WY'];
 
   return (
     <div class='mb-4 rounded-lg bg-gray-50 p-3'>
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/__tests__/robins-scoring.test.js b/packages/web/src/components/checklist/ROBINSIChecklist/__tests__/robins-scoring.test.js
new file mode 100644
index 000000000..1dfa1e7d1
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/__tests__/robins-scoring.test.js
@@ -0,0 +1,974 @@
+import { describe, it, expect } from 'vitest';
+import {
+  scoreRobinsDomain,
+  getEffectiveDomainJudgement,
+  scoreAllDomains,
+  mapOverallJudgementToDisplay,
+  JUDGEMENTS,
+} from '../scoring/robins-scoring.js';
+
+// Helper to create answer objects
+const ans = answer => ({ answer, comment: '' });
+const answers = obj => Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, ans(v)]));
+
+describe('scoreRobinsDomain', () => {
+  describe('Domain 1A (ITT - Confounding)', () => {
+    it('returns null for incomplete answers (missing Q1)', () => {
+      const result = scoreRobinsDomain('domain1a', {});
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('returns null when Q1 answered but Q3 missing (Y/PY path)', () => {
+      const result = scoreRobinsDomain('domain1a', answers({ d1a_1: 'Y' }));
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('Path: Q1=Y/PY -> Q3a=N/PN/NI -> Q2a=Y/PY -> NC2=N/PN -> LOW_EX', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'Y', d1a_2: 'Y', d1a_3: 'N', d1a_4: 'N' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW_EXCEPT_CONFOUNDING);
+      expect(result.ruleId).toBe('D1A.R1');
+    });
+
+    it('Path: Q1=Y/PY -> Q3a=N/PN/NI -> Q2a=Y/PY -> NC2=Y/PY -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'PY', d1a_2: 'PY', d1a_3: 'PN', d1a_4: 'Y' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D1A.R2');
+    });
+
+    it('Path: Q1=Y/PY -> Q3a=N/PN/NI -> Q2a=WN -> NC2=N/PN -> LOW_EX', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'Y', d1a_2: 'WN', d1a_3: 'N', d1a_4: 'N' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW_EXCEPT_CONFOUNDING);
+      expect(result.ruleId).toBe('D1A.R1');
+    });
+
+    it('Path: Q1=Y/PY -> Q3a=N/PN/NI -> Q2a=SN/NI -> SER (terminal)', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'Y', d1a_2: 'SN', d1a_3: 'N' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D1A.R3');
+    });
+
+    it('Path: Q1=Y/PY -> Q3a=Y/PY -> NC3=N/PN -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'PY', d1a_3: 'Y', d1a_4: 'PN' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D1A.R5');
+    });
+
+    it('Path: Q1=Y/PY -> Q3a=Y/PY -> NC3=Y/PY -> CRIT', () => {
+      const result = scoreRobinsDomain('domain1a', answers({ d1a_1: 'Y', d1a_3: 'Y', d1a_4: 'Y' }));
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D1A.R4');
+    });
+
+    it('Path: Q1=WN -> Q3b=N/PN/NI -> Q2b=Y/PY/WN -> NC2=N/PN -> LOW_EX', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'WN', d1a_2: 'WN', d1a_3: 'N', d1a_4: 'N' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW_EXCEPT_CONFOUNDING);
+      expect(result.ruleId).toBe('D1A.R1');
+    });
+
+    it('Path: Q1=WN -> Q3b=Y/PY -> NC4=N/PN -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'WN', d1a_3: 'Y', d1a_4: 'N' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D1A.R6');
+    });
+
+    it('Path: Q1=WN -> Q3b=Y/PY -> NC4=Y/PY -> CRIT', () => {
+      const result = scoreRobinsDomain(
+        'domain1a',
+        answers({ d1a_1: 'WN', d1a_3: 'Y', d1a_4: 'Y' }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D1A.R7');
+    });
+
+    it('Path: Q1=SN/NI -> NC1=N/PN -> SER', () => {
+      const result = scoreRobinsDomain('domain1a', answers({ d1a_1: 'SN', d1a_4: 'PN' }));
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D1A.R8');
+    });
+
+    it('Path: Q1=SN/NI -> NC1=Y/PY -> CRIT', () => {
+      const result = scoreRobinsDomain('domain1a', answers({ d1a_1: 'NI', d1a_4: 'Y' }));
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D1A.R9');
+    });
+  });
+
+  describe('Domain 1B (Per-Protocol - Confounding)', () => {
+    it('returns null for incomplete answers (missing Q1)', () => {
+      const result = scoreRobinsDomain('domain1b', {});
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('Path: Q1=Y/PY -> Q2=Y/PY -> Q3a=Y/PY -> NC1=N/PN -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'Y',
+          d1b_2: 'Y',
+          d1b_3: 'PY',
+          d1b_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D1B.R1');
+    });
+
+    it('Path: Q1=Y/PY -> Q2=Y/PY -> Q3a=Y/PY -> NC1=Y/PY -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'PY',
+          d1b_2: 'Y',
+          d1b_3: 'Y',
+          d1b_5: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D1B.R2');
+    });
+
+    it('Path: Q1=Y/PY -> Q2=Y/PY -> Q3a=WN -> NC2=N/PN -> LOW_EX', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'Y',
+          d1b_2: 'Y',
+          d1b_3: 'WN',
+          d1b_5: 'PN',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW_EXCEPT_CONFOUNDING);
+      expect(result.ruleId).toBe('D1B.R3');
+    });
+
+    it('Path: Q1=Y/PY -> Q2=WN -> Q3b=Y/PY/WN -> NC2=N/PN -> LOW_EX', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'PY',
+          d1b_2: 'WN',
+          d1b_3: 'WN',
+          d1b_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW_EXCEPT_CONFOUNDING);
+      expect(result.ruleId).toBe('D1B.R3');
+    });
+
+    it('Path: Q1=Y/PY -> Q2=SN/NI -> SER (terminal)', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'Y',
+          d1b_2: 'SN',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D1B.R5');
+    });
+
+    it('Path: Q1=N/PN/NI -> Q4=Y/PY -> CRIT (terminal)', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'N',
+          d1b_4: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D1B.R6');
+    });
+
+    it('Path: Q1=N/PN/NI -> Q4=N/PN/NI -> NC3=N/PN -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'PN',
+          d1b_4: 'PN',
+          d1b_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D1B.R8');
+    });
+
+    it('Path: Q1=N/PN/NI -> Q4=N/PN/NI -> NC3=Y/PY -> CRIT', () => {
+      const result = scoreRobinsDomain(
+        'domain1b',
+        answers({
+          d1b_1: 'N',
+          d1b_4: 'NI',
+          d1b_5: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D1B.R7');
+    });
+  });
+
+  describe('Domain 2 (Classification of Interventions)', () => {
+    it('returns null for incomplete answers (missing Q1)', () => {
+      const result = scoreRobinsDomain('domain2', {});
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('Path: A1=Y/PY -> C1=N/PN -> E1=N/PN -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'Y',
+          d2_4: 'N',
+          d2_5: 'PN',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D2.R1');
+    });
+
+    it('Path: A1=Y/PY -> C1=N/PN -> E1=Y/PY/NI -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'PY',
+          d2_4: 'PN',
+          d2_5: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D2.R2');
+    });
+
+    it('Path: A1=Y/PY -> C1=WY/NI -> E2=N/PN -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'Y',
+          d2_4: 'WY',
+          d2_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D2.R3');
+    });
+
+    it('Path: A1=Y/PY -> C1=SY -> E3=N/PN -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'PY',
+          d2_4: 'SY',
+          d2_5: 'PN',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D2.R4');
+    });
+
+    it('Path: A1=Y/PY -> C1=SY -> E3=Y/PY/NI -> CRIT', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'Y',
+          d2_4: 'SY',
+          d2_5: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D2.R4');
+    });
+
+    it('Path: A1=N/PN/NI -> A2=Y/PY -> C1=N/PN -> E1=N/PN -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'N',
+          d2_2: 'Y',
+          d2_4: 'PN',
+          d2_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D2.R5');
+    });
+
+    it('Path: A1=N/PN/NI -> A2=N/PN/NI -> A3=WY/NI -> C2=N/PN -> E2=N/PN -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'PN',
+          d2_2: 'PN',
+          d2_3: 'WY',
+          d2_4: 'N',
+          d2_5: 'PN',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D2.R6');
+    });
+
+    it('treats SY like WY for 2.3 (A3=SY takes the C2 path)', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'PN',
+          d2_2: 'PN',
+          d2_3: 'SY',
+          d2_4: 'N',
+          d2_5: 'PN',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D2.R6');
+    });
+
+    it('Path: A1=N/PN/NI -> A2=N/PN/NI -> A3=N/PN -> C3=SY/WY/NI -> CRIT (terminal)', () => {
+      const result = scoreRobinsDomain(
+        'domain2',
+        answers({
+          d2_1: 'N',
+          d2_2: 'NI',
+          d2_3: 'N',
+          d2_4: 'WY',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D2.R7');
+    });
+  });
+
+  describe('Domain 3 (Selection Bias - Multi-step)', () => {
+    it('returns null when Part A incomplete', () => {
+      const result = scoreRobinsDomain('domain3', answers({ d3_1: 'Y' }));
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('Path: All LOW -> LOW (terminal, no correction questions)', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'Y',
+          d3_2: 'N',
+          d3_3: 'N',
+          d3_4: 'N',
+          d3_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D3.R1');
+    });
+
+    it('Path: At worst MODERATE -> MOD (terminal, no correction questions)', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'Y',
+          d3_2: 'Y',
+          d3_3: 'N',
+          d3_4: 'N',
+          d3_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D3.R2');
+    });
+
+    it('Path: At least one SERIOUS -> C1=Y/PY -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'SN',
+          d3_2: 'N',
+          d3_3: 'N',
+          d3_4: 'N',
+          d3_5: 'N',
+          d3_6: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D3.R3');
+    });
+
+    it('Path: At least one SERIOUS -> C1=N/PN/NI -> C2=Y/PY -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'SN',
+          d3_2: 'N',
+          d3_3: 'N',
+          d3_4: 'N',
+          d3_5: 'N',
+          d3_6: 'N',
+          d3_7: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D3.R3');
+    });
+
+    it('Path: At least one SERIOUS -> C1=N/PN/NI -> C2=N/PN/NI -> C3=N/PN/NI -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'SN',
+          d3_2: 'N',
+          d3_3: 'N',
+          d3_4: 'N',
+          d3_5: 'N',
+          d3_6: 'PN',
+          d3_7: 'N',
+          d3_8: 'NI',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D3.R4');
+    });
+
+    it('Path: At least one SERIOUS -> C1=N/PN/NI -> C2=N/PN/NI -> C3=Y/PY -> CRIT', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'Y',
+          d3_2: 'N',
+          d3_3: 'Y',
+          d3_4: 'Y',
+          d3_5: 'Y',
+          d3_6: 'N',
+          d3_7: 'PN',
+          d3_8: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D3.R5');
+    });
+
+    it('Path: Part A WN/NI -> MOD, Part B N/PN -> LOW -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'WN',
+          d3_2: 'N',
+          d3_3: 'N',
+          d3_4: 'N',
+          d3_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D3.R2');
+    });
+
+    it('Path: Part A SN -> SER, Part B N/PN -> LOW -> SER (needs correction)', () => {
+      const result = scoreRobinsDomain(
+        'domain3',
+        answers({
+          d3_1: 'SN',
+          d3_2: 'N',
+          d3_3: 'N',
+          d3_4: 'N',
+          d3_5: 'N',
+          d3_6: 'N',
+          d3_7: 'N',
+          d3_8: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D3.R4');
+    });
+  });
+
+  describe('Domain 4 (Missing Data)', () => {
+    it('returns null when 4.1-4.3 incomplete', () => {
+      const result = scoreRobinsDomain('domain4', answers({ d4_1: 'Y' }));
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('Path: All Y/PY complete data -> LOW (terminal)', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'Y',
+          d4_2: 'PY',
+          d4_3: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D4.R1');
+    });
+
+    it('Path: Missing data -> B=Y/PY/NI -> C=N/PN -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'N',
+          d4_2: 'Y',
+          d4_3: 'Y',
+          d4_4: 'Y',
+          d4_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D4.R2');
+    });
+
+    it('treats NA like NI so scoring does not get stuck (4.4=NA behaves like 4.4=NI)', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'N',
+          d4_2: 'Y',
+          d4_3: 'Y',
+          d4_4: 'NA',
+          d4_5: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D4.R2');
+    });
+
+    it('Path: Missing data -> B=Y/PY/NI -> C=Y/PY/NI -> E=Y/PY -> F1=Y/PY -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'N',
+          d4_2: 'Y',
+          d4_3: 'Y',
+          d4_4: 'Y',
+          d4_5: 'Y',
+          d4_6: 'Y',
+          d4_11: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D4.R3');
+    });
+
+    it('Path: Missing data -> B=Y/PY/NI -> C=Y/PY/NI -> E=Y/PY -> F1=N/PN -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'N',
+          d4_2: 'Y',
+          d4_3: 'Y',
+          d4_4: 'NI',
+          d4_5: 'Y',
+          d4_6: 'PY',
+          d4_11: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D4.R4');
+    });
+
+    it('Path: Missing data -> B=N/PN -> D=Y/PY -> G=Y/PY -> I=Y/PY -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'PN',
+          d4_2: 'Y',
+          d4_3: 'Y',
+          d4_4: 'N',
+          d4_7: 'Y',
+          d4_8: 'Y',
+          d4_9: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D4.R5');
+    });
+
+    it('Path: Missing data -> B=N/PN -> D=Y/PY -> G=Y/PY -> I=WN/NI -> F2=Y/PY -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'N',
+          d4_2: 'Y',
+          d4_3: 'Y',
+          d4_4: 'N',
+          d4_7: 'Y',
+          d4_8: 'Y',
+          d4_9: 'WN',
+          d4_11: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D4.R6');
+    });
+
+    it('Path: Missing data -> B=N/PN -> D=N/PN/NI -> H=Y/PY -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'N',
+          d4_2: 'N',
+          d4_3: 'N',
+          d4_4: 'N',
+          d4_7: 'N',
+          d4_10: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D4.R2');
+    });
+
+    it('Path: Missing data -> B=N/PN -> D=N/PN/NI -> H=SN -> F3=N/PN -> CRIT', () => {
+      const result = scoreRobinsDomain(
+        'domain4',
+        answers({
+          d4_1: 'N',
+          d4_2: 'N',
+          d4_3: 'N',
+          d4_4: 'N',
+          d4_7: 'NI',
+          d4_10: 'SN',
+          d4_11: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D4.R8');
+    });
+  });
+
+  describe('Domain 5 (Measurement of Outcome)', () => {
+    it('returns null for incomplete answers (missing Q1)', () => {
+      const result = scoreRobinsDomain('domain5', {});
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('Path: Q1=Y/PY -> SER (terminal, no Q2/Q3 needed)', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D5.R1');
+    });
+
+    it('Path: Q1=N/PN -> Q2a=N/PN -> LOW (terminal, no Q3 needed)', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'N',
+          d5_2: 'PN',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D5.R2');
+    });
+
+    it('Path: Q1=N/PN -> Q2a=Y/PY/NI -> Q3a=N/PN -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'PN',
+          d5_2: 'Y',
+          d5_3: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D5.R3');
+    });
+
+    it('Path: Q1=N/PN -> Q2a=Y/PY/NI -> Q3a=WY/NI -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'N',
+          d5_2: 'PY',
+          d5_3: 'WY',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D5.R4');
+    });
+
+    it('Path: Q1=N/PN -> Q2a=Y/PY/NI -> Q3a=SY -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'PN',
+          d5_2: 'Y',
+          d5_3: 'SY',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D5.R5');
+    });
+
+    it('Path: Q1=NI -> Q2b=N/PN -> MOD (terminal, no Q3 needed)', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'NI',
+          d5_2: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D5.R6');
+    });
+
+    it('Path: Q1=NI -> Q2b=Y/PY/NI -> Q3b=WY/N/PN/NI -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'NI',
+          d5_2: 'Y',
+          d5_3: 'WY',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D5.R7');
+    });
+
+    it('Path: Q1=NI -> Q2b=Y/PY/NI -> Q3b=SY -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain5',
+        answers({
+          d5_1: 'NI',
+          d5_2: 'PY',
+          d5_3: 'SY',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D5.R7');
+    });
+  });
+
+  describe('Domain 6 (Selection of Reported Result)', () => {
+    it('returns null for incomplete answers (missing Q1)', () => {
+      const result = scoreRobinsDomain('domain6', {});
+      expect(result.judgement).toBeNull();
+      expect(result.isComplete).toBe(false);
+    });
+
+    it('Path: Q1=Y/PY -> LOW (terminal, no selection questions needed)', () => {
+      const result = scoreRobinsDomain(
+        'domain6',
+        answers({
+          d6_1: 'Y',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D6.R1');
+    });
+
+    it('Path: Q1=N/PN/NI -> SEL: All N/PN -> LOW', () => {
+      const result = scoreRobinsDomain(
+        'domain6',
+        answers({
+          d6_1: 'N',
+          d6_2: 'N',
+          d6_3: 'PN',
+          d6_4: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.LOW);
+      expect(result.ruleId).toBe('D6.R2');
+    });
+
+    it('Path: Q1=N/PN/NI -> SEL: At least one NI, but none Y/PY -> MOD', () => {
+      const result = scoreRobinsDomain(
+        'domain6',
+        answers({
+          d6_1: 'PN',
+          d6_2: 'N',
+          d6_3: 'NI',
+          d6_4: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.MODERATE);
+      expect(result.ruleId).toBe('D6.R3');
+    });
+
+    it('Path: Q1=N/PN/NI -> SEL: One Y/PY -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain6',
+        answers({
+          d6_1: 'N',
+          d6_2: 'Y',
+          d6_3: 'N',
+          d6_4: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D6.R4');
+    });
+
+    it('Path: Q1=N/PN/NI -> SEL: All NI -> SER', () => {
+      const result = scoreRobinsDomain(
+        'domain6',
+        answers({
+          d6_1: 'N',
+          d6_2: 'NI',
+          d6_3: 'NI',
+          d6_4: 'NI',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.SERIOUS);
+      expect(result.ruleId).toBe('D6.R4');
+    });
+
+    it('Path: Q1=N/PN/NI -> SEL: Two or more Y/PY -> CRIT', () => {
+      const result = scoreRobinsDomain(
+        'domain6',
+        answers({
+          d6_1: 'NI',
+          d6_2: 'Y',
+          d6_3: 'PY',
+          d6_4: 'N',
+        }),
+      );
+      expect(result.judgement).toBe(JUDGEMENTS.CRITICAL);
+      expect(result.ruleId).toBe('D6.R5');
+    });
+  });
+});
+
+describe('getEffectiveDomainJudgement', () => {
+  it('returns auto judgement when source is auto', () => {
+    const domainState = { judgementSource: 'auto', judgement: null };
+    const autoScore = { judgement: JUDGEMENTS.MODERATE };
+    expect(getEffectiveDomainJudgement(domainState, autoScore)).toBe(JUDGEMENTS.MODERATE);
+  });
+
+  it('returns manual judgement when source is manual and judgement exists', () => {
+    const domainState = { judgementSource: 'manual', judgement: JUDGEMENTS.SERIOUS };
+    const autoScore = { judgement: JUDGEMENTS.LOW };
+    expect(getEffectiveDomainJudgement(domainState, autoScore)).toBe(JUDGEMENTS.SERIOUS);
+  });
+
+  it('falls back to auto when manual but no judgement set', () => {
+    const domainState = { judgementSource: 'manual', judgement: null };
+    const autoScore = { judgement: JUDGEMENTS.LOW };
+    expect(getEffectiveDomainJudgement(domainState, autoScore)).toBe(JUDGEMENTS.LOW);
+  });
+});
+
+describe('scoreAllDomains', () => {
+  it('returns incomplete when not all domains are scored', () => {
+    const checklistState = {
+      sectionC: { isPerProtocol: false },
+      domain1a: { answers: {} },
+      domain2: { answers: {} },
+      domain3: { answers: {} },
+      domain4: { answers: {} },
+      domain5: { answers: {} },
+      domain6: { answers: {} },
+    };
+    const result = scoreAllDomains(checklistState);
+    expect(result.isComplete).toBe(false);
+    expect(result.overall).toBeNull();
+  });
+
+  it('uses domain1a for ITT (isPerProtocol=false)', () => {
+    const checklistState = {
+      sectionC: { isPerProtocol: false },
+      domain1a: { answers: answers({ d1a_1: 'Y', d1a_2: 'Y', d1a_3: 'N', d1a_4: 'N' }) },
+      domain1b: { answers: {} },
+      domain2: { answers: answers({ d2_1: 'Y', d2_4: 'N', d2_5: 'N' }) },
+      domain3: { answers: answers({ d3_1: 'Y', d3_2: 'N', d3_3: 'N', d3_4: 'N', d3_5: 'N' }) },
+      domain4: { answers: answers({ d4_1: 'Y', d4_2: 'Y', d4_3: 'Y' }) },
+      domain5: { answers: answers({ d5_1: 'N', d5_2: 'N' }) },
+      domain6: { answers: answers({ d6_1: 'Y' }) },
+    };
+    const result = scoreAllDomains(checklistState);
+    expect(result.isComplete).toBe(true);
+    expect(result.domains.domain1a).toBeDefined();
+    expect(result.domains.domain1b).toBeUndefined();
+  });
+
+  it('uses domain1b for per-protocol (isPerProtocol=true)', () => {
+    const checklistState = {
+      sectionC: { isPerProtocol: true },
+      domain1a: { answers: {} },
+      domain1b: { answers: answers({ d1b_1: 'Y', d1b_2: 'Y', d1b_3: 'Y', d1b_5: 'N' }) },
+      domain2: { answers: answers({ d2_1: 'Y', d2_4: 'N', d2_5: 'N' }) },
+      domain3: { answers: answers({ d3_1: 'Y', d3_2: 'N', d3_3: 'N', d3_4: 'N', d3_5: 'N' }) },
+      domain4: { answers: answers({ d4_1: 'Y', d4_2: 'Y', d4_3: 'Y' }) },
+      domain5: { answers: answers({ d5_1: 'N', d5_2: 'N' }) },
+      domain6: { answers: answers({ d6_1: 'Y' }) },
+    };
+    const result = scoreAllDomains(checklistState);
+    expect(result.isComplete).toBe(true);
+    expect(result.domains.domain1a).toBeUndefined();
+    expect(result.domains.domain1b).toBeDefined();
+  });
+
+  it('calculates overall as max severity across domains', () => {
+    const checklistState = {
+      sectionC: { isPerProtocol: false },
+      domain1a: { answers: answers({ d1a_1: 'Y', d1a_2: 'Y', d1a_3: 'N', d1a_4: 'N' }) }, // LOW_EX
+      domain2: { answers: answers({ d2_1: 'Y', d2_4: 'N', d2_5: 'N' }) }, // LOW
+      domain3: { answers: answers({ d3_1: 'Y', d3_2: 'N', d3_3: 'N', d3_4: 'N', d3_5: 'N' }) }, // LOW
+      domain4: { answers: answers({ d4_1: 'Y', d4_2: 'Y', d4_3: 'Y' }) }, // LOW
+      domain5: { answers: answers({ d5_1: 'N', d5_2: 'N' }) }, // LOW
+      domain6: { answers: answers({ d6_1: 'Y' }) }, // LOW
+    };
+    const result = scoreAllDomains(checklistState);
+    expect(result.isComplete).toBe(true);
+    expect(result.overall).toBe(JUDGEMENTS.LOW);
+  });
+
+  it('calculates overall as CRITICAL when any domain is CRITICAL', () => {
+    const checklistState = {
+      sectionC: { isPerProtocol: false },
+      domain1a: { answers: answers({ d1a_1: 'Y', d1a_2: 'Y', d1a_3: 'N', d1a_4: 'N' }) }, // LOW_EX
+      domain2: { answers: answers({ d2_1: 'Y', d2_4: 'N', d2_5: 'N' }) }, // LOW
+      domain3: { answers: answers({ d3_1: 'Y', d3_2: 'N', d3_3: 'N', d3_4: 'N', d3_5: 'N' }) }, // LOW
+      domain4: { answers: answers({ d4_1: 'Y', d4_2: 'Y', d4_3: 'Y' }) }, // LOW
+      domain5: { answers: answers({ d5_1: 'N', d5_2: 'N' }) }, // LOW
+      domain6: { answers: answers({ d6_1: 'N', d6_2: 'Y', d6_3: 'Y', d6_4: 'N' }) }, // CRITICAL
+    };
+    const result = scoreAllDomains(checklistState);
+    expect(result.isComplete).toBe(true);
+    expect(result.overall).toBe(JUDGEMENTS.CRITICAL);
+  });
+});
+
+describe('mapOverallJudgementToDisplay', () => {
+  it('maps Low to display string', () => {
+    expect(mapOverallJudgementToDisplay(JUDGEMENTS.LOW)).toBe(
+      'Low risk of bias except for concerns about uncontrolled confounding',
+    );
+  });
+
+  it('maps Moderate to display string', () => {
+    expect(mapOverallJudgementToDisplay(JUDGEMENTS.MODERATE)).toBe('Moderate risk');
+  });
+
+  it('maps Serious to display string', () => {
+    expect(mapOverallJudgementToDisplay(JUDGEMENTS.SERIOUS)).toBe('Serious risk');
+  });
+
+  it('maps Critical to display string', () => {
+    expect(mapOverallJudgementToDisplay(JUDGEMENTS.CRITICAL)).toBe('Critical risk');
+  });
+});
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/checklist-map.js b/packages/web/src/components/checklist/ROBINSIChecklist/checklist-map.js
index a7dc3ab1e..60acc7c07 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/checklist-map.js
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/checklist-map.js
@@ -6,11 +6,8 @@ export const RESPONSE_TYPES = {
   YN: ['Y', 'N'], // Yes, No
   STANDARD: ['Y', 'PY', 'PN', 'N'], // Yes, Probably Yes, Probably No, No
   WITH_NI: ['Y', 'PY', 'PN', 'N', 'NI'], // With No Information
-  WITH_NA: ['NA', 'Y', 'PY', 'PN', 'N', 'NI'], // With Not Applicable
   WEAK_STRONG_NO: ['Y', 'PY', 'WN', 'SN', 'NI'], // With Weak No, Strong No
-  WEAK_STRONG_NO_NA: ['NA', 'Y', 'PY', 'WN', 'SN', 'NI'],
   WEAK_STRONG_YES: ['SY', 'WY', 'PN', 'N', 'NI'], // Strong Yes, Weak Yes
-  WEAK_STRONG_YES_NA: ['NA', 'SY', 'WY', 'PN', 'N', 'NI'],
 };
 
 // Human-readable labels for response options
@@ -20,7 +17,6 @@ export const RESPONSE_LABELS = {
   PN: 'Probably No',
   N: 'No',
   NI: 'No Information',
-  NA: 'Not Applicable',
   WN: 'No, but not substantial',
   SN: 'No, and probably substantial',
   SY: 'Yes, substantially',
@@ -224,13 +220,13 @@ export const DOMAIN_1A = {
       id: 'd1a_2',
       number: '1.2',
       text: 'If Y/PY/WN to 1.1: Were confounding factors that were controlled for (and for which control was necessary) measured validly and reliably by the variables available in this study?',
-      responseType: 'WEAK_STRONG_NO_NA',
+      responseType: 'WEAK_STRONG_NO',
     },
     d1a_3: {
       id: 'd1a_3',
       number: '1.3',
       text: 'If Y/PY/WN to 1.1: Did the authors control for any post-intervention variables that could have been affected by the intervention?',
-      responseType: 'WITH_NA',
+      responseType: 'WITH_NI',
     },
     d1a_4: {
       id: 'd1a_4',
@@ -260,19 +256,19 @@ export const DOMAIN_1B = {
       id: 'd1b_2',
       number: '1.2',
       text: 'If Y/PY to 1.1: Did the authors control for all the important baseline and time-varying confounding factors for which this was necessary?',
-      responseType: 'WEAK_STRONG_NO_NA',
+      responseType: 'WEAK_STRONG_NO',
     },
     d1b_3: {
       id: 'd1b_3',
       number: '1.3',
       text: 'If Y/PY/WN to 1.2: Were confounding factors that were controlled for (and for which control was necessary) measured validly and reliably by the variables available in this study?',
-      responseType: 'WEAK_STRONG_NO_NA',
+      responseType: 'WEAK_STRONG_NO',
     },
     d1b_4: {
       id: 'd1b_4',
       number: '1.4',
       text: 'If N/PN/NI to 1.1: Did the authors control for time-varying factors or other variables measured after the start of intervention?',
-      responseType: 'WITH_NA',
+      responseType: 'WITH_NI',
     },
     d1b_5: {
       id: 'd1b_5',
@@ -300,13 +296,13 @@ export const DOMAIN_2 = {
       id: 'd2_2',
       number: '2.2',
       text: 'If N/PN/NI to 2.1: Did all or nearly all outcome events occur after the intervention and comparator strategies could be distinguished?',
-      responseType: 'WITH_NA',
+      responseType: 'WITH_NI',
     },
     d2_3: {
       id: 'd2_3',
       number: '2.3',
       text: 'If N/PN/NI to 2.2: Did the analysis avoid problems arising from intervention strategies that are not distinguishable at the start of follow-up?',
-      responseType: 'WEAK_STRONG_YES_NA',
+      responseType: 'WEAK_STRONG_YES',
     },
     d2_4: {
       id: 'd2_4',
@@ -360,13 +356,13 @@ export const DOMAIN_3 = {
           id: 'd3_4',
           number: '3.4',
           text: 'If Y/PY to 3.3: Were the post-intervention variables that influenced selection likely to be associated with intervention?',
-          responseType: 'WITH_NA',
+          responseType: 'WITH_NI',
         },
         d3_5: {
           id: 'd3_5',
           number: '3.5',
           text: 'If Y/PY to 3.4: Were the post-intervention variables that influenced selection likely to be influenced by the outcome or a cause of the outcome?',
-          responseType: 'WITH_NA',
+          responseType: 'WITH_NI',
         },
       },
     },
@@ -377,19 +373,19 @@ export const DOMAIN_3 = {
           id: 'd3_6',
           number: '3.6',
           text: 'If SN to 3.1 or Y/PY to 3.5: Is it likely that the analysis corrected for all of the potential selection biases identified above?',
-          responseType: 'WITH_NA',
+          responseType: 'WITH_NI',
         },
         d3_7: {
           id: 'd3_7',
           number: '3.7',
           text: 'If N/PN/NI to 3.6: Did sensitivity analyses demonstrate that the likely impact of the potential selection biases identified above was minimal?',
-          responseType: 'WITH_NA',
+          responseType: 'WITH_NI',
         },
         d3_8: {
           id: 'd3_8',
           number: '3.8',
           text: 'If N/PN/NI to 3.7: Were potential selection biases identified above sufficiently severe that the result should not be included in a quantitative synthesis?',
-          responseType: 'WITH_NA',
+          responseType: 'WITH_NI',
         },
       },
     },
@@ -425,51 +421,51 @@ export const DOMAIN_4 = {
       id: 'd4_4',
       number: '4.4',
       text: 'If N/PN/NI to 4.1, 4.2 or 4.3: Is the result based on a complete case analysis?',
-      responseType: 'WITH_NA',
+      responseType: 'WITH_NI',
     },
     d4_5: {
       id: 'd4_5',
       number: '4.5',
       text: 'If Y/PY/NI to 4.4: Was exclusion from the analysis because of missing data (in intervention, confounders or the outcome) likely to be related to the true value of the outcome?',
-      responseType: 'WITH_NA',
+      responseType: 'WITH_NI',
     },
     d4_6: {
       id: 'd4_6',
       number: '4.6',
       text: 'If Y/PY/NI to 4.5: Is the relationship between the outcome and missingness likely to be explained by the variables in the analysis model?',
-      responseType: 'WEAK_STRONG_NO_NA',
+      responseType: 'WEAK_STRONG_NO',
     },
     d4_7: {
       id: 'd4_7',
       number: '4.7',
       text: 'If N/PN to 4.4: Was the analysis based on imputing missing values?',
-      responseType: 'WITH_NA',
-      note: 'Response options: NA / Y / PY / PN / NI',
+      responseType: 'WITH_NI',
+      note: 'Response options: Y / PY / PN / NI',
     },
     d4_8: {
       id: 'd4_8',
       number: '4.8',
       text: "If Y/PY to 4.7: Is it reasonable to assume that data were 'missing at random' (MAR) or 'missing completely at random' (MCAR)?",
-      responseType: 'WITH_NA',
+      responseType: 'WITH_NI',
     },
     d4_9: {
       id: 'd4_9',
       number: '4.9',
       text: 'If Y/PY to 4.8: Was imputation performed appropriately?',
-      responseType: 'WEAK_STRONG_NO_NA',
+      responseType: 'WEAK_STRONG_NO',
     },
     d4_10: {
       id: 'd4_10',
       number: '4.10',
       text: 'If N/PN/NI to 4.7: Was an appropriate alternative method used to correct for bias due to missing data?',
-      responseType: 'WEAK_STRONG_NO_NA',
+      responseType: 'WEAK_STRONG_NO',
     },
     d4_11: {
       id: 'd4_11',
       number: '4.11',
       text: 'If PN/N/NI to 4.1, 4.2 or 4.3 AND (Y/PY/NI to 4.5 OR WN/SN/NI to 4.9 OR WN/SN/NI to 4.10): Is there evidence that the result was not biased by missing data?',
-      responseType: 'WITH_NA',
-      note: 'Response options: NA / Y / PY / PN / N',
+      responseType: 'WITH_NI',
+      note: 'Response options: Y / PY / PN / N / NI',
     },
   },
   hasDirection: true,
@@ -497,7 +493,7 @@ export const DOMAIN_5 = {
       id: 'd5_3',
       number: '5.3',
       text: 'If Y/PY/NI to 5.2: Could assessment of the outcome have been influenced by knowledge of the intervention received?',
-      responseType: 'WEAK_STRONG_YES_NA',
+      responseType: 'WEAK_STRONG_YES',
     },
   },
   hasDirection: true,
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/checklist.js b/packages/web/src/components/checklist/ROBINSIChecklist/checklist.js
index d846590e6..847ef1e44 100644
--- a/packages/web/src/components/checklist/ROBINSIChecklist/checklist.js
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/checklist.js
@@ -4,6 +4,13 @@ import {
   getActiveDomainKeys,
   getDomainQuestions,
 } from './checklist-map.js';
+import {
+  scoreRobinsDomain,
+  getEffectiveDomainJudgement,
+  scoreAllDomains,
+  mapOverallJudgementToDisplay,
+  JUDGEMENTS,
+} from './scoring/robins-scoring.js';
 
 /**
  * Creates a new ROBINS-I V2 checklist object with default empty answers.
@@ -112,6 +119,7 @@ export function createChecklist({
     // Overall risk of bias
     overall: {
       judgement: null, // 'Low (except confounding)', 'Moderate', 'Serious', 'Critical'
+      judgementSource: 'auto', // 'auto' | 'manual' - tracks whether judgement is auto-calculated or manually set
       direction: null,
     },
   };
@@ -135,6 +143,7 @@ function createDomainState(domainKey) {
   return {
     answers,
     judgement: null, // 'Low', 'Moderate', 'Serious', 'Critical'
+    judgementSource: 'auto', // 'auto' | 'manual' - tracks whether judgement is auto-calculated or manually set
     direction: domain?.hasDirection ? null : undefined,
   };
 }
@@ -155,7 +164,7 @@ export function shouldStopAssessment(sectionB) {
 }
 
 /**
- * Score the overall checklist based on domain judgements
+ * Score the overall checklist based on domain judgements (uses effective judgements from smart scoring)
  * @param {Object} state - The complete checklist state
  * @returns {string} Overall risk of bias: 'Low', 'Moderate', 'Serious', 'Critical', or 'Incomplete'
  */
@@ -167,81 +176,54 @@ export function scoreChecklist(state) {
     return 'Critical';
   }
 
-  // Determine which Domain 1 variant to use
-  const isPerProtocol = state.sectionC?.isPerProtocol || false;
-  const activeDomains = getActiveDomainKeys(isPerProtocol);
-
-  const judgements = [];
+  // Use the smart scoring engine to get all effective judgements
+  const { overall, isComplete } = scoreAllDomains(state);
 
-  for (const domainKey of activeDomains) {
-    const domain = state[domainKey];
-    if (!domain?.judgement) {
-      return 'Incomplete';
-    }
-    judgements.push(domain.judgement);
+  if (!isComplete) {
+    return 'Incomplete';
   }
 
-  // Scoring algorithm
-  // Critical: At least one domain is Critical
-  if (judgements.includes('Critical')) {
-    return 'Critical';
-  }
+  return overall || 'Incomplete';
+}
 
-  // Serious: At least one domain is Serious
-  if (judgements.includes('Serious')) {
-    return 'Serious';
+/**
+ * Get detailed scoring information for all domains using the smart scoring engine
+ * @param {Object} state - The complete checklist state
+ * @returns {Object} { domains, overall, isComplete } with auto/effective/source per domain
+ */
+export function getSmartScoring(state) {
+  if (!state || typeof state !== 'object') {
+    return { domains: {}, overall: null, isComplete: false };
   }
 
-  // Moderate: Highest domain judgement is Moderate
-  if (judgements.includes('Moderate')) {
-    return 'Moderate';
+  // Check if assessment was stopped early
+  if (shouldStopAssessment(state.sectionB)) {
+    return {
+      domains: {},
+      overall: 'Critical',
+      isComplete: true,
+      stoppedEarly: true,
+    };
   }
 
-  // Low: All domains are Low
-  return 'Low';
+  return scoreAllDomains(state);
 }
 
 /**
  * Get the algorithmic suggestion for a domain's risk of bias based on signalling questions
- * This is a helper/suggestion - final judgement is made by reviewer
+ * Uses the table-driven smart scoring engine for accurate, deterministic results
  * @param {string} domainKey - The domain key
  * @param {Object} answers - The domain's answers object
  * @returns {string|null} Suggested judgement or null if incomplete
  */
 export function suggestDomainJudgement(domainKey, answers) {
-  if (!answers) return null;
-
-  const questionKeys = Object.keys(answers);
-  if (questionKeys.length === 0) return null;
-
-  // Check if all questions are answered
-  const answeredQuestions = questionKeys.filter(k => answers[k]?.answer !== null);
-  if (answeredQuestions.length === 0) return null;
-
-  // Count different response types
-  let hasNo = false;
-  let hasProbablyNo = false;
-  let hasStrongNo = false;
-  let hasWeakNo = false;
-  let hasNI = false;
-
-  questionKeys.forEach(qKey => {
-    const answer = answers[qKey]?.answer;
-    if (answer === 'N') hasNo = true;
-    if (answer === 'PN') hasProbablyNo = true;
-    if (answer === 'SN') hasStrongNo = true;
-    if (answer === 'WN') hasWeakNo = true;
-    if (answer === 'NI') hasNI = true;
-  });
-
-  // Simple heuristic (actual algorithms are domain-specific in ROBINS-I guidance)
-  if (hasNo || hasStrongNo) return 'Serious';
-  if (hasProbablyNo || hasWeakNo) return 'Moderate';
-  if (hasNI) return 'Moderate';
-
-  return 'Low';
+  const result = scoreRobinsDomain(domainKey, answers);
+  return result.judgement;
 }
 
+// Re-export smart scoring functions for use in components
+export { scoreRobinsDomain, getEffectiveDomainJudgement, mapOverallJudgementToDisplay, JUDGEMENTS };
+
 /**
  * Get the selected answer for a specific question
  * @param {string} domainKey - The domain key
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-1-a.md b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-1-a.md
new file mode 100644
index 000000000..df1091b33
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-1-a.md
@@ -0,0 +1,81 @@
+```mermaid
+flowchart LR
+  %% --------------------
+  %% Core questions
+  %% --------------------
+  Q1["1.1 Controlled for all the important confounding factors?"]
+  Q3a["1.3 Controlled for any post-intervention variables?"]
+  Q3b["1.3 Controlled for any post-intervention variables?"]
+  Q2a["1.2 Confounding factors measured validly and reliably?"]
+  Q2b["1.2 Confounding factors measured validly and reliably?"]
+  Q2c["1.2 Confounding factors measured validly and reliably?"]
+
+  %% --------------------
+  %% Negative controls
+  %% --------------------
+  NC1["1.4 Negative controls etc suggest serious uncontrolled confounding?"]
+  NC2["1.4 Negative controls etc suggest serious uncontrolled confounding?"]
+  NC3["1.4 Negative controls etc suggest serious uncontrolled confounding?"]
+  NC4["1.4 Negative controls etc suggest serious uncontrolled confounding?"]
+
+  %% --------------------
+  %% Outcomes
+  %% --------------------
+  LOW_EX["LOW RISK OF BIAS\n(except for concerns about uncontrolled confounding)"]
+  MOD["MODERATE RISK OF BIAS"]
+  SER["SERIOUS RISK OF BIAS"]
+  CRIT["CRITICAL RISK OF BIAS"]
+
+  %% --------------------
+  %% From 1.1
+  %% --------------------
+  Q1 -- "Y / PY" --> Q3a
+  Q1 -- "WN" --> Q3b
+  Q1 -- "SN / NI" --> NC1
+
+  %% --------------------
+  %% From 1.3 (top)
+  %% --------------------
+  Q3a -- "N / PN / NI" --> Q2a
+  Q3a -- "Y / PY" --> NC3
+
+  %% --------------------
+  %% From 1.3 (middle)
+  %% --------------------
+  Q3b -- "N / PN / NI" --> Q2b
+  Q3b -- "Y / PY" --> NC4
+
+  %% --------------------
+  %% From 1.2 (top)
+  %% --------------------
+  Q2a -- "Y / PY" --> NC2
+  Q2a -- "WN" --> NC2
+  Q2a -- "SN / NI" --> SER
+
+  %% --------------------
+  %% From 1.2 (middle)
+  %% --------------------
+  Q2b -- "Y / PY / WN" --> NC2
+  Q2b -- "SN / NI" --> SER
+
+  %% --------------------
+  %% From 1.2 (bottom)
+  %% --------------------
+  Q2c -- "Y / PY" --> SER
+  Q2c -- "SN / WN / NI" --> CRIT
+
+  %% --------------------
+  %% Negative controls → outcomes
+  %% --------------------
+  NC1 -- "N / PN" --> SER
+  NC1 -- "Y / PY" --> CRIT
+
+  NC2 -- "N / PN" --> LOW_EX
+  NC2 -- "Y / PY" --> MOD
+
+  NC3 -- "N / PN" --> SER
+  NC3 -- "Y / PY" --> CRIT
+
+  NC4 -- "N / PN" --> SER
+  NC4 -- "Y / PY" --> CRIT
+```
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-1-b.md b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-1-b.md
new file mode 100644
index 000000000..023258bc3
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-1-b.md
@@ -0,0 +1,71 @@
+```mermaid
+flowchart LR
+  %% --------------------
+  %% Core questions
+  %% --------------------
+  Q1["1.1 Appropriate analysis method?"]
+  Q2["1.2 Controlled for all the important confounding factors?"]
+  Q3a["1.3 Confounding factors measured validly and reliably?"]
+  Q3b["1.3 Confounding factors measured validly and reliably?"]
+  Q4["1.4 Controlled for variables measured after start of intervention?"]
+
+  %% --------------------
+  %% Negative controls
+  %% --------------------
+  NC1["1.5 Negative controls etc suggest serious uncontrolled confounding?"]
+  NC2["1.5 Negative controls etc suggest serious uncontrolled confounding?"]
+  NC3["1.5 Negative controls etc suggest serious uncontrolled confounding?"]
+
+  %% --------------------
+  %% Outcomes
+  %% --------------------
+  LOW["LOW RISK OF BIAS"]
+  LOW_EX["LOW RISK OF BIAS\n(except for concerns about uncontrolled confounding)"]
+  MOD["MODERATE RISK OF BIAS"]
+  SER["SERIOUS RISK OF BIAS"]
+  CRIT["CRITICAL RISK OF BIAS"]
+
+  %% --------------------
+  %% Paths from 1.1
+  %% --------------------
+  Q1 -- "Y / PY" --> Q2
+  Q1 -- "N / PN / NI" --> Q4
+
+  %% --------------------
+  %% Paths from 1.2
+  %% --------------------
+  Q2 -- "Y / PY" --> Q3a
+  Q2 -- "WN" --> Q3b
+  Q2 -- "SN / NI" --> SER
+
+  %% --------------------
+  %% Paths from 1.3 (top)
+  %% --------------------
+  Q3a -- "Y / PY" --> NC1
+  Q3a -- "WN" --> NC2
+  Q3a -- "SN / NI" --> SER
+
+  %% --------------------
+  %% Paths from 1.3 (middle)
+  %% --------------------
+  Q3b -- "Y / PY / WN" --> NC2
+  Q3b -- "SN / NI" --> SER
+
+  %% --------------------
+  %% Paths from 1.4
+  %% --------------------
+  Q4 -- "N / PN / NI" --> NC3
+  Q4 -- "Y / PY" --> CRIT
+
+  %% --------------------
+  %% Negative controls to outcomes
+  %% --------------------
+  NC1 -- "N / PN" --> LOW
+  NC1 -- "Y / PY" --> MOD
+
+  NC2 -- "N / PN" --> LOW_EX
+  NC2 -- "Y / PY" --> SER
+
+  NC3 -- "N / PN" --> SER
+  NC3 -- "Y / PY" --> CRIT
+```
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-2.md b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-2.md
new file mode 100644
index 000000000..11d90f624
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-2.md
@@ -0,0 +1,72 @@
+```mermaid
+flowchart LR
+  %% --------------------
+  %% Start
+  %% --------------------
+  A1["2.1 Intervention distinguishable at start of follow-up?"]
+
+  %% --------------------
+  %% Early pathway
+  %% --------------------
+  A2["2.2 Almost all outcome events after strategies distinguishable?"]
+  A3["2.3 Appropriate analysis?"]
+
+  %% --------------------
+  %% Classification influenced by outcome
+  %% --------------------
+  C1["2.4 Classification of intervention influenced by outcome?"]
+  C2["2.4 Classification of intervention influenced by outcome?"]
+  C3["2.4 Classification of intervention influenced by outcome?"]
+
+  %% --------------------
+  %% Further errors
+  %% --------------------
+  E1["2.5 Further classification errors likely?"]
+  E2["2.5 Further classification errors likely?"]
+  E3["2.5 Further classification errors likely?"]
+
+  %% --------------------
+  %% Outcomes
+  %% --------------------
+  LOW["LOW RISK OF BIAS"]
+  MOD["MODERATE RISK OF BIAS"]
+  SER["SERIOUS RISK OF BIAS"]
+  CRIT["CRITICAL RISK OF BIAS"]
+
+  %% --------------------
+  %% Connections
+  %% --------------------
+  A1 -- "Y / PY" --> C1
+  A1 -- "N / PN / NI" --> A2
+
+  A2 -- "Y / PY" --> C1
+  A2 -- "N / PN / NI" --> A3
+
+  A3 -- "SY / WY / NI" --> C2
+  A3 -- "N / PN" --> C3
+
+  %% --------------------
+  %% Classification → errors
+  %% --------------------
+  C1 -- "N / PN" --> E1
+  C1 -- "WY / NI" --> E2
+  C1 -- "SY" --> E3
+
+  C2 -- "N / PN" --> E2
+  C2 -- "SY" --> E3
+
+  C3 -- "N / PN" --> E3
+  C3 -- "SY / WY / NI" --> CRIT
+
+  %% --------------------
+  %% Error nodes → outcomes
+  %% --------------------
+  E1 -- "N / PN" --> LOW
+  E1 -- "Y / PY / NI" --> MOD
+
+  E2 -- "N / PN" --> MOD
+  E2 -- "Y / PY / NI" --> SER
+
+  E3 -- "N / PN" --> SER
+  E3 -- "Y / PY / NI" --> CRIT
+```
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-3.md b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-3.md
new file mode 100644
index 000000000..406968649
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-3.md
@@ -0,0 +1,76 @@
+```mermaid
+flowchart LR
+  %% --------------------
+  %% Section A
+  %% --------------------
+  subgraph A["A. Follow-up and early outcomes"]
+    A1["3.1 Participants followed from start of intervention?"]
+
+    A2["3.2 Early outcome events excluded?"]
+
+    A1 -- "Y / PY" --> A2
+    A1 -- "WN / NI" --> A_MOD["MODERATE"]
+    A1 -- "SN" --> A_SER["SERIOUS"]
+
+    A2 -- "N / PN / NI" --> A_LOW["LOW"]
+    A2 -- "Y / PY" --> A_MOD
+  end
+
+  %% --------------------
+  %% Section B
+  %% --------------------
+  subgraph B["B. Selection bias"]
+    B1["3.3 Selection based on characteristics after start?"]
+    B2["3.4 Selection variables associated with intervention?"]
+    B3["3.5 Selection variables influenced by outcome?"]
+
+    B1 -- "N / PN" --> B_LOW1["LOW"]
+    B1 -- "Y / PY" --> B2
+    B1 -- "NI" --> B_MOD1["MODERATE"]
+
+    B2 -- "N / PN" --> B_LOW2["LOW"]
+    B2 -- "Y / PY" --> B3
+    B2 -- "NI" --> B_MOD2["MODERATE"]
+
+    B3 -- "N / PN / NI" --> B_MOD3["MODERATE"]
+    B3 -- "Y / PY" --> B_SER["SERIOUS"]
+  end
+
+  %% --------------------
+  %% Combine A and B
+  %% --------------------
+  subgraph AB["Across A and B"]
+    AB_LOW["All LOW"]
+    AB_MOD["At worst MODERATE"]
+    AB_SER["At least one SERIOUS"]
+  end
+
+  A_LOW --> AB_LOW
+  B_LOW1 --> AB_LOW
+  B_LOW2 --> AB_LOW
+
+  A_MOD --> AB_MOD
+  B_MOD1 --> AB_MOD
+  B_MOD2 --> AB_MOD
+  B_MOD3 --> AB_MOD
+
+  A_SER --> AB_SER
+  B_SER --> AB_SER
+
+  %% --------------------
+  %% Final adjustments
+  %% --------------------
+  AB_LOW --> LOW_RISK["LOW RISK OF BIAS"]
+  AB_MOD --> MOD_RISK["MODERATE RISK OF BIAS"]
+
+  AB_SER --> C1["3.6 Analysis corrected for selection biases?"]
+
+  C1 -- "Y / PY" --> MOD_RISK
+  C1 -- "N / PN / NI" --> C2["3.7 Sensitivity analyses demonstrate minimal impact?"]
+
+  C2 -- "Y / PY" --> MOD_RISK
+  C2 -- "N / PN / NI" --> C3["3.8 Selection biases severe?"]
+
+  C3 -- "N / PN / NI" --> SER_RISK["SERIOUS RISK OF BIAS"]
+  C3 -- "Y / PY" --> CRIT_RISK["CRITICAL RISK OF BIAS"]
+```
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-4.md b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-4.md
new file mode 100644
index 000000000..985ea70af
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-4.md
@@ -0,0 +1,45 @@
+````mermaid
+flowchart TD
+    A[4.1–4.3 Complete data for all participants?]
+
+    A -->|All Y/PY| LOW1[LOW RISK OF BIAS]
+    A -->|Any N/PN/NI| B[4.4 Complete-case analysis?]
+
+    %% Complete-case path
+    B -->|Y/PY/NI| C[4.5 Exclusion related to true outcome?]
+    B -->|N/PN| D[4.7 Analysis based on imputation?]
+
+    C -->|N/PN| LOW2[LOW RISK OF BIAS]
+    C -->|Y/PY/NI| E[4.6 Outcome–missingness relationship explained by model?]
+
+    E -->|Y/PY| F1[4.11 Evidence result not biased?]
+    E -->|WN/NI| F2[4.11 Evidence result not biased?]
+    E -->|SN| F3[4.11 Evidence result not biased?]
+
+    %% Imputation path
+    D -->|Y/PY| G[4.8 MAR/MCAR reasonable?]
+    D -->|N/PN/NI| H[4.10 Alternative appropriate method?]
+
+    G -->|Y/PY| I[4.9 Appropriate imputation?]
+    G -->|N/PN/NI| F2
+
+    I -->|Y/PY| LOW3[LOW RISK OF BIAS]
+    I -->|WN/NI| F2
+    I -->|SN| F3
+
+    %% Alternative method path
+    H -->|Y/PY| LOW4[LOW RISK OF BIAS]
+    H -->|WN/NI| F2
+    H -->|SN| F3
+
+    %% Final evidence checks
+    F1 -->|Y/PY| MOD1[MODERATE RISK OF BIAS]
+    F1 -->|N/PN| SER1[SERIOUS RISK OF BIAS]
+
+    F2 -->|Y/PY| MOD2[MODERATE RISK OF BIAS]
+    F2 -->|N/PN| SER2[SERIOUS RISK OF BIAS]
+
+    F3 -->|Y/PY| SER3[SERIOUS RISK OF BIAS]
+    F3 -->|N/PN| CRIT[CRITICAL RISK OF BIAS]
+    ```
+````
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-5.md b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-5.md
new file mode 100644
index 000000000..692487ebc
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-5.md
@@ -0,0 +1,52 @@
+```mermaid
+flowchart LR
+  %% --------------------
+  %% Core questions
+  %% --------------------
+  Q1["5.1 Measurement of outcome differs by intervention?"]
+
+  Q2a["5.2 Outcome assessors aware of intervention received?"]
+  Q2b["5.2 Outcome assessors aware of intervention received?"]
+
+  Q3a["5.3 Assessment could be influenced by knowledge of intervention?"]
+  Q3b["5.3 Assessment could be influenced by knowledge of intervention?"]
+
+  %% --------------------
+  %% Outcomes
+  %% --------------------
+  LOW["LOW RISK OF BIAS"]
+  MOD["MODERATE RISK OF BIAS"]
+  SER["SERIOUS RISK OF BIAS"]
+
+  %% --------------------
+  %% From 5.1
+  %% --------------------
+  Q1 -- "N / PN" --> Q2a
+  Q1 -- "NI" --> Q2b
+  Q1 -- "Y / PY" --> SER
+
+  %% --------------------
+  %% From 5.2 (top)
+  %% --------------------
+  Q2a -- "N / PN" --> LOW
+  Q2a -- "Y / PY / NI" --> Q3a
+
+  %% --------------------
+  %% From 5.2 (middle)
+  %% --------------------
+  Q2b -- "N / PN" --> MOD
+  Q2b -- "Y / PY / NI" --> Q3b
+
+  %% --------------------
+  %% From 5.3 (top)
+  %% --------------------
+  Q3a -- "N / PN" --> LOW
+  Q3a -- "WY / NI" --> MOD
+  Q3a -- "SY" --> SER
+
+  %% --------------------
+  %% From 5.3 (middle)
+  %% --------------------
+  Q3b -- "WY / N / PN / NI" --> MOD
+  Q3b -- "SY" --> SER
+```
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-6.md b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-6.md
new file mode 100644
index 000000000..34bfae066
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/decision-diagrams/domain-6.md
@@ -0,0 +1,38 @@
+```mermaid
+flowchart LR
+  %% --------------------
+  %% Core questions
+  %% --------------------
+  Q1["6.1 Result reported according to analysis plan?"]
+
+  Q2["6.2 Multiple outcome measurements?"]
+  Q3["6.3 Multiple analyses of the data?"]
+  Q4["6.4 Multiple subgroups?"]
+
+  %% --------------------
+  %% Aggregated decision node
+  %% --------------------
+  SEL["Result selected from:\n6.2 / 6.3 / 6.4"]
+
+  %% --------------------
+  %% Outcomes
+  %% --------------------
+  LOW["LOW RISK OF BIAS"]
+  MOD["MODERATE RISK OF BIAS"]
+  SER["SERIOUS RISK OF BIAS"]
+  CRIT["CRITICAL RISK OF BIAS"]
+
+  %% --------------------
+  %% From 6.1
+  %% --------------------
+  Q1 -- "Y / PY" --> LOW
+  Q1 -- "N / PN / NI" --> SEL
+
+  %% --------------------
+  %% From selection set (6.2–6.4)
+  %% --------------------
+  SEL -- "All N / PN" --> LOW
+  SEL -- "At least one NI,\nbut none Y / PY" --> MOD
+  SEL -- "One Y / PY,\nor all NI" --> SER
+  SEL -- "Two or more Y / PY" --> CRIT
+```
diff --git a/packages/web/src/components/checklist/ROBINSIChecklist/scoring/robins-scoring.js b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/robins-scoring.js
new file mode 100644
index 000000000..32db5e031
--- /dev/null
+++ b/packages/web/src/components/checklist/ROBINSIChecklist/scoring/robins-scoring.js
@@ -0,0 +1,1114 @@
+/**
+ * ROBINS-I V2 Smart Scoring Engine
+ *
+ * Implements deterministic, table-driven scoring for all ROBINS-I domains
+ * based on the official decision tables.
+ */
+
+// Helper: check if answer matches any value in a set
+const inSet = (answer, ...values) => values.includes(answer);
+
+// Normalization: treat NA as NI for scoring to avoid "stuck" branches
+// (The mermaid decision diagrams generally model NI but omit NA.)
+const normalizeAnswer = answer => (answer === 'NA' ? 'NI' : answer);
+
+// Helper: check if answer is Yes or Probably Yes
+const isYesPY = answer => inSet(answer, 'Y', 'PY');
+
+// Helper: check if answer is No or Probably No
+const isNoPPN = answer => inSet(answer, 'N', 'PN');
+
+// Helper: check if answer is No, Probably No, or No Information
+const isNoPPNNI = answer => inSet(answer, 'N', 'PN', 'NI');
+
+// Canonical judgement values matching ROB_JUDGEMENTS in checklist-map.js
+const JUDGEMENTS = {
+  LOW: 'Low',
+  LOW_EXCEPT_CONFOUNDING: 'Low (except for concerns about uncontrolled confounding)',
+  MODERATE: 'Moderate',
+  SERIOUS: 'Serious',
+  CRITICAL: 'Critical',
+};
+
+/**
+ * Score Domain 1A (Bias due to confounding - ITT effect)
+ *
+ * Questions: d1a_1, d1a_2, d1a_3, d1a_4
+ * Flow from domain-1-a.md mermaid diagram
+ */
+function scoreDomain1A(answers) {
+  const q1 = normalizeAnswer(answers.d1a_1?.answer); // 1.1 Controlled for all the important confounding factors?
+  const q2 = normalizeAnswer(answers.d1a_2?.answer); // 1.2 Confounding factors measured validly and reliably?
+  const q3 = normalizeAnswer(answers.d1a_3?.answer); // 1.3 Controlled for any post-intervention variables?
+  const q4 = normalizeAnswer(answers.d1a_4?.answer); // 1.4 Negative controls etc suggest serious uncontrolled confounding?
+
+  // Must have Q1 to start
+  if (q1 === null || q1 === undefined) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  // Path: Q1 -> if SN/NI -> NC1 -> outcomes
+  if (inSet(q1, 'SN', 'NI')) {
+    if (q4 === null || q4 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+    if (isNoPPN(q4)) {
+      return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1A.R8' };
+    }
+    if (isYesPY(q4)) {
+      return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D1A.R9' };
+    }
+  }
+
+  // Path: Q1 -> if Y/PY -> Q3a
+  if (isYesPY(q1)) {
+    if (q3 === null || q3 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // Q3a -> if Y/PY -> NC3
+    if (isYesPY(q3)) {
+      if (q4 === null || q4 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      if (isNoPPN(q4)) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1A.R5' };
+      }
+      if (isYesPY(q4)) {
+        return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D1A.R4' };
+      }
+    }
+
+    // Q3a -> if N/PN/NI -> Q2a
+    if (isNoPPNNI(q3)) {
+      if (q2 === null || q2 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      // Q2a -> if SN/NI -> SER (terminal, no NC needed)
+      if (inSet(q2, 'SN', 'NI')) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1A.R3' };
+      }
+
+      // Q2a -> if Y/PY or WN -> NC2
+      if (isYesPY(q2) || q2 === 'WN') {
+        if (q4 === null || q4 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q4)) {
+          return {
+            judgement: JUDGEMENTS.LOW_EXCEPT_CONFOUNDING,
+            isComplete: true,
+            ruleId: 'D1A.R1',
+          };
+        }
+        if (isYesPY(q4)) {
+          return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D1A.R2' };
+        }
+      }
+    }
+  }
+
+  // Path: Q1 -> if WN -> Q3b
+  if (q1 === 'WN') {
+    if (q3 === null || q3 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // Q3b -> if Y/PY -> NC4
+    if (isYesPY(q3)) {
+      if (q4 === null || q4 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      if (isNoPPN(q4)) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1A.R6' };
+      }
+      if (isYesPY(q4)) {
+        return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D1A.R7' };
+      }
+    }
+
+    // Q3b -> if N/PN/NI -> Q2b
+    if (isNoPPNNI(q3)) {
+      if (q2 === null || q2 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      // Q2b -> if SN/NI -> SER (terminal, no NC needed)
+      if (inSet(q2, 'SN', 'NI')) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1A.R7' };
+      }
+
+      // Q2b -> if Y/PY/WN -> NC2
+      if (isYesPY(q2) || q2 === 'WN') {
+        if (q4 === null || q4 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q4)) {
+          return {
+            judgement: JUDGEMENTS.LOW_EXCEPT_CONFOUNDING,
+            isComplete: true,
+            ruleId: 'D1A.R1',
+          };
+        }
+        if (isYesPY(q4)) {
+          return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D1A.R2' };
+        }
+      }
+    }
+  }
+
+  // Incomplete - need more answers
+  return { judgement: null, isComplete: false, ruleId: null };
+}
+
+/**
+ * Score Domain 1B (Bias due to confounding - Per-Protocol effect)
+ *
+ * Questions: d1b_1, d1b_2, d1b_3, d1b_4, d1b_5
+ * Flow from domain-1-b.md mermaid diagram
+ */
+function scoreDomain1B(answers) {
+  const q1 = normalizeAnswer(answers.d1b_1?.answer); // 1.1 Appropriate analysis method?
+  const q2 = normalizeAnswer(answers.d1b_2?.answer); // 1.2 Controlled for all the important confounding factors?
+  const q3 = normalizeAnswer(answers.d1b_3?.answer); // 1.3 Confounding factors measured validly and reliably?
+  const q4 = normalizeAnswer(answers.d1b_4?.answer); // 1.4 Controlled for variables measured after start of intervention?
+  const q5 = normalizeAnswer(answers.d1b_5?.answer); // 1.5 Negative controls etc suggest serious uncontrolled confounding?
+
+  // Must have Q1 to start
+  if (q1 === null || q1 === undefined) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  // Path: Q1 -> if N/PN/NI -> Q4
+  if (isNoPPNNI(q1)) {
+    if (q4 === null || q4 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // Q4 -> if Y/PY -> CRIT (terminal, no NC needed)
+    if (isYesPY(q4)) {
+      return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D1B.R6' };
+    }
+
+    // Q4 -> if N/PN/NI -> NC3
+    if (isNoPPNNI(q4)) {
+      if (q5 === null || q5 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      if (isNoPPN(q5)) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1B.R8' };
+      }
+      if (isYesPY(q5)) {
+        return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D1B.R7' };
+      }
+    }
+  }
+
+  // Path: Q1 -> if Y/PY -> Q2
+  if (isYesPY(q1)) {
+    if (q2 === null || q2 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // Q2 -> if SN/NI -> SER (terminal, no Q3 needed)
+    if (inSet(q2, 'SN', 'NI')) {
+      return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1B.R5' };
+    }
+
+    // Q2 -> if Y/PY -> Q3a
+    if (isYesPY(q2)) {
+      if (q3 === null || q3 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      // Q3a -> if SN/NI -> SER (terminal, no NC needed)
+      if (inSet(q3, 'SN', 'NI')) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1B.R5' };
+      }
+
+      // Q3a -> if Y/PY -> NC1
+      if (isYesPY(q3)) {
+        if (q5 === null || q5 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q5)) {
+          return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D1B.R1' };
+        }
+        if (isYesPY(q5)) {
+          return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D1B.R2' };
+        }
+      }
+
+      // Q3a -> if WN -> NC2
+      if (q3 === 'WN') {
+        if (q5 === null || q5 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q5)) {
+          return {
+            judgement: JUDGEMENTS.LOW_EXCEPT_CONFOUNDING,
+            isComplete: true,
+            ruleId: 'D1B.R3',
+          };
+        }
+        if (isYesPY(q5)) {
+          return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1B.R4' };
+        }
+      }
+    }
+
+    // Q2 -> if WN -> Q3b
+    if (q2 === 'WN') {
+      if (q3 === null || q3 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      // Q3b -> if SN/NI -> SER (terminal, no NC needed)
+      if (inSet(q3, 'SN', 'NI')) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1B.R5' };
+      }
+
+      // Q3b -> if Y/PY/WN -> NC2
+      if (isYesPY(q3) || q3 === 'WN') {
+        if (q5 === null || q5 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q5)) {
+          return {
+            judgement: JUDGEMENTS.LOW_EXCEPT_CONFOUNDING,
+            isComplete: true,
+            ruleId: 'D1B.R3',
+          };
+        }
+        if (isYesPY(q5)) {
+          return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D1B.R4' };
+        }
+      }
+    }
+  }
+
+  // Incomplete - need more answers
+  return { judgement: null, isComplete: false, ruleId: null };
+}
+
+/**
+ * Score Domain 2 (Bias in classification of interventions)
+ *
+ * Questions: d2_1, d2_2, d2_3, d2_4, d2_5
+ * Flow from domain-2.md mermaid diagram
+ */
+function scoreDomain2(answers) {
+  const q1 = normalizeAnswer(answers.d2_1?.answer); // 2.1 Intervention distinguishable at start of follow-up?
+  const q2 = normalizeAnswer(answers.d2_2?.answer); // 2.2 Almost all outcome events after strategies distinguishable?
+  const q3 = normalizeAnswer(answers.d2_3?.answer); // 2.3 Appropriate analysis?
+  const q4 = normalizeAnswer(answers.d2_4?.answer); // 2.4 Classification of intervention influenced by outcome?
+  const q5 = normalizeAnswer(answers.d2_5?.answer); // 2.5 Further classification errors likely?
+
+  // Must have A1 (q1) to start
+  if (q1 === null || q1 === undefined) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  // Path: A1 -> if Y/PY -> C1
+  if (isYesPY(q1)) {
+    if (q4 === null || q4 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // C1 -> if SY -> E3
+    if (q4 === 'SY') {
+      if (q5 === null || q5 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      if (isNoPPN(q5)) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D2.R4' };
+      }
+      if (inSet(q5, 'Y', 'PY', 'NI')) {
+        return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D2.R4' };
+      }
+    }
+
+    // C1 -> if WY/NI -> E2
+    if (inSet(q4, 'WY', 'NI')) {
+      if (q5 === null || q5 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      if (isNoPPN(q5)) {
+        return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D2.R3' };
+      }
+      if (inSet(q5, 'Y', 'PY', 'NI')) {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D2.R3' };
+      }
+    }
+
+    // C1 -> if N/PN -> E1
+    if (isNoPPN(q4)) {
+      if (q5 === null || q5 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      if (isNoPPN(q5)) {
+        return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D2.R1' };
+      }
+      if (inSet(q5, 'Y', 'PY', 'NI')) {
+        return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D2.R2' };
+      }
+    }
+  }
+
+  // Path: A1 -> if N/PN/NI -> A2
+  if (isNoPPNNI(q1)) {
+    if (q2 === null || q2 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // A2 -> if Y/PY -> C1 (same logic as above)
+    if (isYesPY(q2)) {
+      if (q4 === null || q4 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      if (q4 === 'SY') {
+        if (q5 === null || q5 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q5)) {
+          return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D2.R4' };
+        }
+        if (inSet(q5, 'Y', 'PY', 'NI')) {
+          return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D2.R4' };
+        }
+      }
+
+      if (inSet(q4, 'WY', 'NI')) {
+        if (q5 === null || q5 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q5)) {
+          return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D2.R3' };
+        }
+        if (inSet(q5, 'Y', 'PY', 'NI')) {
+          return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D2.R3' };
+        }
+      }
+
+      if (isNoPPN(q4)) {
+        if (q5 === null || q5 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        if (isNoPPN(q5)) {
+          return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D2.R5' };
+        }
+        if (inSet(q5, 'Y', 'PY', 'NI')) {
+          return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D2.R2' };
+        }
+      }
+    }
+
+    // A2 -> if N/PN/NI -> A3
+    if (isNoPPNNI(q2)) {
+      if (q3 === null || q3 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      // A3 -> if N/PN -> C3
+      if (isNoPPN(q3)) {
+        if (q4 === null || q4 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        // C3 -> if SY/WY/NI -> CRIT (terminal, no E needed)
+        if (inSet(q4, 'SY', 'WY', 'NI')) {
+          return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D2.R7' };
+        }
+        // C3 -> if N/PN -> E3
+        if (isNoPPN(q4)) {
+          if (q5 === null || q5 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isNoPPN(q5)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D2.R7' };
+          }
+          if (inSet(q5, 'Y', 'PY', 'NI')) {
+            return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D2.R7' };
+          }
+        }
+      }
+
+      // A3 -> if SY/WY/NI -> C2
+      if (inSet(q3, 'SY', 'WY', 'NI')) {
+        if (q4 === null || q4 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        // C2 -> if SY -> E3
+        if (q4 === 'SY') {
+          if (q5 === null || q5 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isNoPPN(q5)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D2.R6' };
+          }
+          if (inSet(q5, 'Y', 'PY', 'NI')) {
+            return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D2.R6' };
+          }
+        }
+        // C2 -> if N/PN -> E2
+        if (isNoPPN(q4)) {
+          if (q5 === null || q5 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isNoPPN(q5)) {
+            return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D2.R6' };
+          }
+          if (inSet(q5, 'Y', 'PY', 'NI')) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D2.R6' };
+          }
+        }
+      }
+    }
+  }
+
+  // Incomplete - need more answers
+  return { judgement: null, isComplete: false, ruleId: null };
+}
+
+/**
+ * Score Domain 3 Part A (Selection bias - prevalent user bias and immortal time)
+ *
+ * Questions: d3_1, d3_2
+ * Flow from domain-3.md mermaid diagram Section A
+ */
+function scoreDomain3PartA(answers) {
+  const q1 = normalizeAnswer(answers.d3_1?.answer); // 3.1 Participants followed from start of intervention?
+  const q2 = normalizeAnswer(answers.d3_2?.answer); // 3.2 Early outcome events excluded?
+
+  if (q1 === null || q1 === undefined) {
+    return { result: null, isComplete: false };
+  }
+
+  // A1 -> if SN -> A_SER (Serious)
+  if (q1 === 'SN') {
+    return { result: 'Serious', isComplete: true };
+  }
+
+  // A1 -> if WN/NI -> A_MOD (Moderate)
+  if (inSet(q1, 'WN', 'NI')) {
+    return { result: 'Moderate', isComplete: true };
+  }
+
+  // A1 -> if Y/PY -> A2
+  if (isYesPY(q1)) {
+    if (q2 === null || q2 === undefined) {
+      return { result: null, isComplete: false };
+    }
+    // A2 -> if N/PN/NI -> A_LOW (Low)
+    if (isNoPPNNI(q2)) {
+      return { result: 'Low', isComplete: true };
+    }
+    // A2 -> if Y/PY -> A_MOD (Moderate)
+    if (isYesPY(q2)) {
+      return { result: 'Moderate', isComplete: true };
+    }
+  }
+
+  return { result: null, isComplete: q2 !== null && q2 !== undefined };
+}
+
+/**
+ * Score Domain 3 Part B (Selection bias - other types)
+ *
+ * Questions: d3_3, d3_4, d3_5
+ * Flow from domain-3.md mermaid diagram Section B
+ */
+function scoreDomain3PartB(answers) {
+  const q3 = normalizeAnswer(answers.d3_3?.answer); // 3.3 Selection based on characteristics after start?
+  const q4 = normalizeAnswer(answers.d3_4?.answer); // 3.4 Selection variables associated with intervention?
+  const q5 = normalizeAnswer(answers.d3_5?.answer); // 3.5 Selection variables influenced by outcome?
+
+  if (q3 === null || q3 === undefined) {
+    return { result: null, isComplete: false };
+  }
+
+  // B1 -> if N/PN -> B_LOW1 (Low)
+  if (isNoPPN(q3)) {
+    return { result: 'Low', isComplete: true };
+  }
+
+  // B1 -> if NI -> B_MOD1 (Moderate)
+  if (q3 === 'NI') {
+    return { result: 'Moderate', isComplete: true };
+  }
+
+  // B1 -> if Y/PY -> B2
+  if (isYesPY(q3)) {
+    if (q4 === null || q4 === undefined) {
+      return { result: null, isComplete: false };
+    }
+
+    // B2 -> if N/PN -> B_LOW2 (Low)
+    if (isNoPPN(q4)) {
+      return { result: 'Low', isComplete: true };
+    }
+
+    // B2 -> if NI -> B_MOD2 (Moderate)
+    if (q4 === 'NI') {
+      return { result: 'Moderate', isComplete: true };
+    }
+
+    // B2 -> if Y/PY -> B3
+    if (isYesPY(q4)) {
+      if (q5 === null || q5 === undefined) {
+        return { result: null, isComplete: false };
+      }
+      // B3 -> if N/PN/NI -> B_MOD3 (Moderate)
+      if (isNoPPNNI(q5)) {
+        return { result: 'Moderate', isComplete: true };
+      }
+      // B3 -> if Y/PY -> B_SER (Serious)
+      if (isYesPY(q5)) {
+        return { result: 'Serious', isComplete: true };
+      }
+    }
+  }
+
+  const allAnswered = [q3, q4, q5].every(a => a !== null && a !== undefined);
+  return { result: null, isComplete: allAnswered };
+}
+
+/**
+ * Score Domain 3 Final (combines Part A + Part B with correction questions)
+ *
+ * Questions: d3_6, d3_7, d3_8
+ * Flow from domain-3.md mermaid diagram - combines Section A and B, then applies corrections
+ */
+function scoreDomain3(answers) {
+  const partA = scoreDomain3PartA(answers);
+  const partB = scoreDomain3PartB(answers);
+
+  // If either part is incomplete, domain is incomplete
+  if (!partA.isComplete || !partB.isComplete) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  const q6 = normalizeAnswer(answers.d3_6?.answer); // 3.6 Analysis corrected for selection biases?
+  const q7 = normalizeAnswer(answers.d3_7?.answer); // 3.7 Sensitivity analyses demonstrate minimal impact?
+  const q8 = normalizeAnswer(answers.d3_8?.answer); // 3.8 Selection biases severe?
+
+  // Determine combined result: All LOW, At worst MODERATE, or At least one SERIOUS
+  const rankMap = { Low: 0, Moderate: 1, Serious: 2 };
+  const aRank = rankMap[partA.result] ?? 0;
+  const bRank = rankMap[partB.result] ?? 0;
+  const worstRank = Math.max(aRank, bRank);
+
+  // All LOW -> LOW_RISK (terminal, no correction questions needed)
+  if (partA.result === 'Low' && partB.result === 'Low') {
+    return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D3.R1' };
+  }
+
+  // At worst MODERATE -> MOD_RISK (terminal, no correction questions needed)
+  if (worstRank <= 1) {
+    return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D3.R2' };
+  }
+
+  // At least one SERIOUS -> need correction/sensitivity questions
+  if (worstRank >= 2) {
+    // C1 (3.6) -> if Y/PY -> MOD_RISK
+    if (isYesPY(q6)) {
+      return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D3.R3' };
+    }
+
+    // C1 -> if N/PN/NI -> C2 (3.7)
+    if (isNoPPNNI(q6)) {
+      // C2 -> if Y/PY -> MOD_RISK
+      if (isYesPY(q7)) {
+        return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D3.R3' };
+      }
+
+      // C2 -> if N/PN/NI -> C3 (3.8)
+      if (isNoPPNNI(q7)) {
+        if (q8 === null || q8 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        // C3 -> if N/PN/NI -> SER_RISK
+        if (isNoPPNNI(q8)) {
+          return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D3.R4' };
+        }
+        // C3 -> if Y/PY -> CRIT_RISK
+        if (isYesPY(q8)) {
+          return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D3.R5' };
+        }
+      }
+    }
+  }
+
+  // Need more answers for final determination
+  return { judgement: null, isComplete: false, ruleId: null };
+}
+
+/**
+ * Score Domain 4 (Bias due to missing data)
+ *
+ * Questions: d4_1 through d4_11
+ * Flow from domain-4.md mermaid diagram
+ */
+function scoreDomain4(answers) {
+  const q1 = normalizeAnswer(answers.d4_1?.answer); // 4.1 Complete data on intervention
+  const q2 = normalizeAnswer(answers.d4_2?.answer); // 4.2 Complete data on outcome
+  const q3 = normalizeAnswer(answers.d4_3?.answer); // 4.3 Complete data on confounders
+  const q4 = normalizeAnswer(answers.d4_4?.answer); // 4.4 Complete-case analysis?
+  const q5 = normalizeAnswer(answers.d4_5?.answer); // 4.5 Exclusion related to true outcome?
+  const q6 = normalizeAnswer(answers.d4_6?.answer); // 4.6 Outcome–missingness relationship explained by model?
+  const q7 = normalizeAnswer(answers.d4_7?.answer); // 4.7 Analysis based on imputation?
+  const q8 = normalizeAnswer(answers.d4_8?.answer); // 4.8 MAR/MCAR reasonable?
+  const q9 = normalizeAnswer(answers.d4_9?.answer); // 4.9 Appropriate imputation?
+  const q10 = normalizeAnswer(answers.d4_10?.answer); // 4.10 Alternative appropriate method?
+  const q11 = normalizeAnswer(answers.d4_11?.answer); // 4.11 Evidence result not biased?
+
+  // A: Check 4.1-4.3 complete data
+  const completeDataAnswered = [q1, q2, q3].every(a => a !== null && a !== undefined);
+  if (!completeDataAnswered) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  const allCompleteData = [q1, q2, q3].every(a => isYesPY(a));
+
+  // A -> if All Y/PY -> LOW1 (terminal)
+  if (allCompleteData) {
+    return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D4.R1' };
+  }
+
+  // A -> if Any N/PN/NI -> B (4.4)
+  if ([q1, q2, q3].some(a => isNoPPNNI(a))) {
+    if (q4 === null || q4 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // B -> if Y/PY/NI -> C (4.5) - complete-case path
+    if (isYesPY(q4) || q4 === 'NI') {
+      if (q5 === null || q5 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      // C -> if N/PN -> LOW2 (terminal)
+      if (isNoPPN(q5)) {
+        return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D4.R2' };
+      }
+
+      // C -> if Y/PY/NI -> E (4.6)
+      if (isYesPY(q5) || q5 === 'NI') {
+        if (q6 === null || q6 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+
+        // E -> if Y/PY -> F1 (4.11)
+        if (isYesPY(q6)) {
+          if (q11 === null || q11 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isYesPY(q11)) {
+            return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D4.R3' };
+          }
+          if (isNoPPN(q11)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R4' };
+          }
+        }
+
+        // E -> if WN/NI -> F2 (4.11)
+        if (inSet(q6, 'WN', 'NI')) {
+          if (q11 === null || q11 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isYesPY(q11)) {
+            return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D4.R6' };
+          }
+          if (isNoPPN(q11)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R7' };
+          }
+        }
+
+        // E -> if SN -> F3 (4.11)
+        if (q6 === 'SN') {
+          if (q11 === null || q11 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isYesPY(q11)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R7' };
+          }
+          if (isNoPPN(q11)) {
+            return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D4.R8' };
+          }
+        }
+      }
+    }
+
+    // B -> if N/PN -> D (4.7) - imputation/alternative method path
+    if (isNoPPN(q4)) {
+      if (q7 === null || q7 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+
+      // D -> if Y/PY -> G (4.8) - imputation path
+      if (isYesPY(q7)) {
+        if (q8 === null || q8 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+
+        // G -> if Y/PY -> I (4.9)
+        if (isYesPY(q8)) {
+          if (q9 === null || q9 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          // I -> if Y/PY -> LOW3 (terminal)
+          if (isYesPY(q9)) {
+            return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D4.R5' };
+          }
+          // I -> if WN/NI -> F2 (4.11)
+          if (inSet(q9, 'WN', 'NI')) {
+            if (q11 === null || q11 === undefined) {
+              return { judgement: null, isComplete: false, ruleId: null };
+            }
+            if (isYesPY(q11)) {
+              return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D4.R6' };
+            }
+            if (isNoPPN(q11)) {
+              return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R7' };
+            }
+          }
+          // I -> if SN -> F3 (4.11)
+          if (q9 === 'SN') {
+            if (q11 === null || q11 === undefined) {
+              return { judgement: null, isComplete: false, ruleId: null };
+            }
+            if (isYesPY(q11)) {
+              return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R7' };
+            }
+            if (isNoPPN(q11)) {
+              return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D4.R8' };
+            }
+          }
+        }
+
+        // G -> if N/PN/NI -> F2 (4.11)
+        if (isNoPPNNI(q8)) {
+          if (q11 === null || q11 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isYesPY(q11)) {
+            return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D4.R6' };
+          }
+          if (isNoPPN(q11)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R7' };
+          }
+        }
+      }
+
+      // D -> if N/PN/NI -> H (4.10) - alternative method path
+      if (isNoPPNNI(q7)) {
+        if (q10 === null || q10 === undefined) {
+          return { judgement: null, isComplete: false, ruleId: null };
+        }
+        // H -> if Y/PY -> LOW4 (terminal)
+        if (isYesPY(q10)) {
+          return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D4.R2' };
+        }
+        // H -> if WN/NI -> F2 (4.11)
+        if (inSet(q10, 'WN', 'NI')) {
+          if (q11 === null || q11 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isYesPY(q11)) {
+            return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D4.R6' };
+          }
+          if (isNoPPN(q11)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R7' };
+          }
+        }
+        // H -> if SN -> F3 (4.11)
+        if (q10 === 'SN') {
+          if (q11 === null || q11 === undefined) {
+            return { judgement: null, isComplete: false, ruleId: null };
+          }
+          if (isYesPY(q11)) {
+            return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D4.R7' };
+          }
+          if (isNoPPN(q11)) {
+            return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D4.R8' };
+          }
+        }
+      }
+    }
+  }
+
+  // Incomplete - need more answers
+  return { judgement: null, isComplete: false, ruleId: null };
+}
+
+/**
+ * Score Domain 5 (Bias in measurement of the outcome)
+ *
+ * Questions: d5_1, d5_2, d5_3
+ * Flow from domain-5.md mermaid diagram
+ */
+function scoreDomain5(answers) {
+  const q1 = normalizeAnswer(answers.d5_1?.answer); // 5.1 Measurement of outcome differs by intervention?
+  const q2 = normalizeAnswer(answers.d5_2?.answer); // 5.2 Outcome assessors aware of intervention received?
+  const q3 = normalizeAnswer(answers.d5_3?.answer); // 5.3 Assessment could be influenced by knowledge of intervention?
+
+  // Must have Q1 to start
+  if (q1 === null || q1 === undefined) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  // Q1 -> if Y/PY -> SER (terminal, no Q2/Q3 needed)
+  if (isYesPY(q1)) {
+    return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D5.R1' };
+  }
+
+  // Q1 -> if N/PN -> Q2a
+  if (isNoPPN(q1)) {
+    if (q2 === null || q2 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // Q2a -> if N/PN -> LOW (terminal, no Q3 needed)
+    if (isNoPPN(q2)) {
+      return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D5.R2' };
+    }
+
+    // Q2a -> if Y/PY/NI -> Q3a
+    if (inSet(q2, 'Y', 'PY', 'NI')) {
+      if (q3 === null || q3 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      // Q3a -> if N/PN -> LOW
+      if (isNoPPN(q3)) {
+        return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D5.R3' };
+      }
+      // Q3a -> if WY/NI -> MOD
+      if (inSet(q3, 'WY', 'NI')) {
+        return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D5.R4' };
+      }
+      // Q3a -> if SY -> SER
+      if (q3 === 'SY') {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D5.R5' };
+      }
+    }
+  }
+
+  // Q1 -> if NI -> Q2b
+  if (q1 === 'NI') {
+    if (q2 === null || q2 === undefined) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // Q2b -> if N/PN -> MOD (terminal, no Q3 needed)
+    if (isNoPPN(q2)) {
+      return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D5.R6' };
+    }
+
+    // Q2b -> if Y/PY/NI -> Q3b
+    if (inSet(q2, 'Y', 'PY', 'NI')) {
+      if (q3 === null || q3 === undefined) {
+        return { judgement: null, isComplete: false, ruleId: null };
+      }
+      // Q3b -> if WY/N/PN/NI -> MOD
+      if (inSet(q3, 'WY', 'N', 'PN', 'NI')) {
+        return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D5.R7' };
+      }
+      // Q3b -> if SY -> SER
+      if (q3 === 'SY') {
+        return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D5.R7' };
+      }
+    }
+  }
+
+  // Incomplete - need more answers
+  return { judgement: null, isComplete: false, ruleId: null };
+}
+
+/**
+ * Score Domain 6 (Bias in selection of the reported result)
+ *
+ * Questions: d6_1, d6_2, d6_3, d6_4
+ * Flow from domain-6.md mermaid diagram
+ */
+function scoreDomain6(answers) {
+  const q1 = normalizeAnswer(answers.d6_1?.answer); // 6.1 Result reported according to analysis plan?
+  const q2 = normalizeAnswer(answers.d6_2?.answer); // 6.2 Multiple outcome measurements?
+  const q3 = normalizeAnswer(answers.d6_3?.answer); // 6.3 Multiple analyses of the data?
+  const q4 = normalizeAnswer(answers.d6_4?.answer); // 6.4 Multiple subgroups?
+
+  // Must have Q1 to start
+  if (q1 === null || q1 === undefined) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  // Q1 -> if Y/PY -> LOW (terminal, no selection questions needed)
+  if (isYesPY(q1)) {
+    return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D6.R1' };
+  }
+
+  // Q1 -> if N/PN/NI -> SEL (aggregated from 6.2-6.4)
+  if (isNoPPNNI(q1)) {
+    // Check if selection questions are answered
+    const selectionQuestions = [q2, q3, q4];
+    const allSelectionAnswered = selectionQuestions.every(a => a !== null && a !== undefined);
+
+    if (!allSelectionAnswered) {
+      return { judgement: null, isComplete: false, ruleId: null };
+    }
+
+    // Count Y/PY and NI among selection questions
+    const yesCount = selectionQuestions.filter(a => isYesPY(a)).length;
+    const hasNI = selectionQuestions.some(a => a === 'NI');
+    const allNI = selectionQuestions.every(a => a === 'NI');
+    const allNPN = selectionQuestions.every(a => isNoPPN(a));
+
+    // SEL -> if All N/PN -> LOW
+    if (allNPN) {
+      return { judgement: JUDGEMENTS.LOW, isComplete: true, ruleId: 'D6.R2' };
+    }
+
+    // SEL -> if At least one NI, but none Y/PY -> MOD
+    // (This means: hasNI is true, yesCount is 0, but not all NI)
+    if (yesCount === 0 && hasNI && !allNI) {
+      return { judgement: JUDGEMENTS.MODERATE, isComplete: true, ruleId: 'D6.R3' };
+    }
+
+    // SEL -> if One Y/PY, or all NI -> SER
+    if (yesCount === 1 || (yesCount === 0 && allNI)) {
+      return { judgement: JUDGEMENTS.SERIOUS, isComplete: true, ruleId: 'D6.R4' };
+    }
+
+    // SEL -> if Two or more Y/PY -> CRIT
+    if (yesCount >= 2) {
+      return { judgement: JUDGEMENTS.CRITICAL, isComplete: true, ruleId: 'D6.R5' };
+    }
+  }
+
+  // Incomplete - need more answers
+  return { judgement: null, isComplete: false, ruleId: null };
+}
+
+/**
+ * Main entry point: score a ROBINS-I domain
+ *
+ * @param {string} domainKey - e.g., 'domain1a', 'domain1b', 'domain2', etc.
+ * @param {Object} answers - The domain's answers object { questionKey: { answer, comment } }
+ * @param {Object} options - Additional options
+ * @param {boolean} options.isPerProtocol - Whether this is per-protocol analysis (for domain1)
+ * @returns {Object} { judgement, isComplete, ruleId }
+ */
+export function scoreRobinsDomain(domainKey, answers, _options = {}) {
+  if (!answers) {
+    return { judgement: null, isComplete: false, ruleId: null };
+  }
+
+  switch (domainKey) {
+    case 'domain1a':
+      return scoreDomain1A(answers);
+    case 'domain1b':
+      return scoreDomain1B(answers);
+    case 'domain2':
+      return scoreDomain2(answers);
+    case 'domain3':
+      return scoreDomain3(answers);
+    case 'domain4':
+      return scoreDomain4(answers);
+    case 'domain5':
+      return scoreDomain5(answers);
+    case 'domain6':
+      return scoreDomain6(answers);
+    default:
+      return { judgement: null, isComplete: false, ruleId: null };
+  }
+}
+
+/**
+ * Get effective domain judgement (respects manual override)
+ *
+ * @param {Object} domainState - The domain state { answers, judgement, judgementSource, direction }
+ * @param {Object} autoScore - Result from scoreRobinsDomain
+ * @returns {string|null} The effective judgement
+ */
+export function getEffectiveDomainJudgement(domainState, autoScore) {
+  if (domainState?.judgementSource === 'manual' && domainState?.judgement) {
+    return domainState.judgement;
+  }
+  return autoScore?.judgement || null;
+}
+
+/**
+ * Score all active domains and return a summary
+ *
+ * @param {Object} checklistState - Full checklist state
+ * @returns {Object} { domains: { [key]: { auto, effective, source } }, overall }
+ */
+export function scoreAllDomains(checklistState) {
+  if (!checklistState) {
+    return { domains: {}, overall: null };
+  }
+
+  const isPerProtocol = checklistState.sectionC?.isPerProtocol || false;
+  const activeDomainKeys =
+    isPerProtocol ?
+      ['domain1b', 'domain2', 'domain3', 'domain4', 'domain5', 'domain6']
+    : ['domain1a', 'domain2', 'domain3', 'domain4', 'domain5', 'domain6'];
+
+  const domains = {};
+  const effectiveJudgements = [];
+
+  for (const domainKey of activeDomainKeys) {
+    const domainState = checklistState[domainKey];
+    const auto = scoreRobinsDomain(domainKey, domainState?.answers, { isPerProtocol });
+    const effective = getEffectiveDomainJudgement(domainState, auto);
+    const source = domainState?.judgementSource || 'auto';
+
+    domains[domainKey] = {
+      auto,
+      effective,
+      source,
+      isOverridden: source === 'manual' && effective !== auto.judgement,
+    };
+
+    if (effective) {
+      effectiveJudgements.push(effective);
+    }
+  }
+
+  // Calculate overall from effective judgements
+  let overall = null;
+  if (effectiveJudgements.length === activeDomainKeys.length) {
+    if (effectiveJudgements.includes(JUDGEMENTS.CRITICAL)) {
+      overall = JUDGEMENTS.CRITICAL;
+    } else if (effectiveJudgements.includes(JUDGEMENTS.SERIOUS)) {
+      overall = JUDGEMENTS.SERIOUS;
+    } else if (effectiveJudgements.includes(JUDGEMENTS.MODERATE)) {
+      overall = JUDGEMENTS.MODERATE;
+    } else {
+      overall = JUDGEMENTS.LOW;
+    }
+  }
+
+  return { domains, overall, isComplete: effectiveJudgements.length === activeDomainKeys.length };
+}
+
+/**
+ * Map internal overall judgement to the OVERALL_ROB_JUDGEMENTS display strings
+ */
+export function mapOverallJudgementToDisplay(judgement) {
+  switch (judgement) {
+    case JUDGEMENTS.LOW:
+    case JUDGEMENTS.LOW_EXCEPT_CONFOUNDING:
+      return 'Low risk of bias except for concerns about uncontrolled confounding';
+    case JUDGEMENTS.MODERATE:
+      return 'Moderate risk';
+    case JUDGEMENTS.SERIOUS:
+      return 'Serious risk';
+    case JUDGEMENTS.CRITICAL:
+      return 'Critical risk';
+    default:
+      return null;
+  }
+}
+
+export { JUDGEMENTS };
diff --git a/packages/web/src/components/checklist/pdf/pdfScrollHandler.js b/packages/web/src/components/checklist/pdf/pdfScrollHandler.js
index 0a1fa6a1d..7a3dd6275 100644
--- a/packages/web/src/components/checklist/pdf/pdfScrollHandler.js
+++ b/packages/web/src/components/checklist/pdf/pdfScrollHandler.js
@@ -30,6 +30,7 @@ export function createPdfScrollHandler(document) {
   let lastMousePosition = null; // { x, y } for button-triggered zoom
   let isWheelZooming = false; // Track if we're in an active wheel zoom gesture
   let scrollAdjustRafId = null; // RAF ID for scroll adjustment to prevent multiple queued adjustments
+  let zoomAdjustToken = 0; // Token to coalesce rapid zoom adjustments (latest wins)
 
   // Handle scroll to update current page indicator
   function handleScroll() {
@@ -119,27 +120,14 @@ export function createPdfScrollHandler(document) {
 
     if (newScale === oldScale) return;
 
-    // For wheel zoom, calculate scroll adjustment immediately based on scale ratio
-    // This avoids waiting for DOM updates and prevents jank
-    const scaleRatio = newScale / oldScale;
-    const pointY = cursorPoint.y;
-    const scrollTop = scrollContainerRef.scrollTop;
-
-    // Calculate the point's position in content space before zoom
-    const pointInContent = scrollTop + pointY;
-
-    // After zoom, the same point in content space will be at a different scroll position
-    // We want to keep the cursor at the same screen position, so:
-    // newScrollTop + pointY = pointInContent * scaleRatio
-    // newScrollTop = pointInContent * scaleRatio - pointY
-    const newScrollTop = pointInContent * scaleRatio - pointY;
+    // Store zoom origin before changing scale (same as button zoom)
+    zoomOriginPoint = cursorPoint;
+    zoomOriginScale = oldScale;
+    zoomAdjustToken += 1; // Increment token to invalidate any pending adjustments
 
-    // Update scale
+    // Update scale - the createEffect will handle scroll adjustment
     setScale(newScale);
 
-    // Immediately adjust scroll to prevent jank
-    scrollContainerRef.scrollTop = Math.max(0, newScrollTop);
-
     // Clear wheel zoom flag after a short delay (when gesture ends)
     clearTimeout(handleWheel.zoomEndTimeout);
     handleWheel.zoomEndTimeout = setTimeout(() => {
@@ -285,6 +273,7 @@ export function createPdfScrollHandler(document) {
     // Store zoom origin before changing scale
     zoomOriginPoint = zoomPoint;
     zoomOriginScale = oldScale;
+    zoomAdjustToken += 1; // Increment token to invalidate any pending adjustments
 
     // Calculate new scale
     const newScale = Math.min(Math.max(oldScale + scaleDelta, 0.5), 3.0);
@@ -292,15 +281,10 @@ export function createPdfScrollHandler(document) {
   }
 
   // Adjust scroll position after scale change to maintain zoom origin
-  // Only runs for button-triggered zoom (not wheel zoom, which handles it immediately)
+  // Works for both button-triggered zoom and pinch zoom
   createEffect(() => {
     const currentScale = scale();
 
-    // Skip if we're in a wheel zoom gesture (handled immediately in handleWheel)
-    if (isWheelZooming) {
-      return;
-    }
-
     // Only adjust scroll if we have a stored zoom origin
     if (zoomOriginPoint === null || zoomOriginScale === null || !scrollContainerRef) {
       return;
@@ -311,89 +295,187 @@ export function createPdfScrollHandler(document) {
       return;
     }
 
+    // Capture the current token to check if we're still the latest adjustment
+    const currentToken = zoomAdjustToken;
+    const pointX = zoomOriginPoint.x;
+    const pointY = zoomOriginPoint.y;
+
+    // Find which page contains the zoom point
+    let targetPage = null;
+    let targetPageNum = null;
+    let pointOffsetFromPageTop = 0;
+    let pointOffsetFromPageLeft = 0;
+
+    // Calculate the point's position in the scroll container's coordinate space
+    const pointInContainer = {
+      x: scrollContainerRef.scrollLeft + pointX,
+      y: scrollContainerRef.scrollTop + pointY,
+    };
+
+    // Find the page that contains this point
+    pageRefs.forEach((pageEl, pageNum) => {
+      if (!pageEl || targetPage) return;
+
+      const pageTop = pageEl.offsetTop;
+      const pageBottom = pageTop + pageEl.offsetHeight;
+      const pageLeft = pageEl.offsetLeft;
+      const pageRight = pageLeft + pageEl.offsetWidth;
+
+      // Check if point is within this page's bounds (both vertical and horizontal)
+      if (
+        pointInContainer.y >= pageTop &&
+        pointInContainer.y <= pageBottom &&
+        pointInContainer.x >= pageLeft &&
+        pointInContainer.x <= pageRight
+      ) {
+        targetPage = pageEl;
+        targetPageNum = pageNum;
+        pointOffsetFromPageTop = pointInContainer.y - pageTop;
+        pointOffsetFromPageLeft = pointInContainer.x - pageLeft;
+      }
+    });
+
+    // Prioritize rendering the target page if we found it
+    if (targetPageNum !== null && rendererCallbacks && rendererCallbacks.schedulePageRender) {
+      rendererCallbacks.schedulePageRender(targetPageNum);
+    }
+
     // Cancel any pending scroll adjustment
     if (scrollAdjustRafId !== null) {
       cancelAnimationFrame(scrollAdjustRafId);
       scrollAdjustRafId = null;
     }
 
-    // Wait for next frame to ensure DOM has updated with new page sizes
-    scrollAdjustRafId = requestAnimationFrame(() => {
-      scrollAdjustRafId = null;
-
-      if (!scrollContainerRef || zoomOriginPoint === null) return;
-
-      const pointX = zoomOriginPoint.x;
-      const pointY = zoomOriginPoint.y;
-
-      // Find which page contains the zoom point
-      let targetPage = null;
-      let targetPageNum = null;
-      let pointOffsetFromPageTop = 0;
-
-      // Calculate the point's position in the scroll container's coordinate space
-      const pointInContainer = {
-        x: pointX,
-        y: scrollContainerRef.scrollTop + pointY,
-      };
-
-      // Find the page that contains this point
-      pageRefs.forEach((pageEl, pageNum) => {
-        if (!pageEl || targetPage) return;
-
-        const pageTop = pageEl.offsetTop;
-        const pageBottom = pageTop + pageEl.offsetHeight;
-
-        // Check if point is within this page's vertical bounds
-        if (pointInContainer.y >= pageTop && pointInContainer.y <= pageBottom) {
-          targetPage = pageEl;
-          targetPageNum = pageNum;
-          pointOffsetFromPageTop = pointInContainer.y - pageTop;
+    if (!targetPage || targetPageNum === null) {
+      // Fallback: use viewport center calculation
+      const oldScrollHeight = scrollContainerRef.scrollHeight;
+      const oldScrollWidth = scrollContainerRef.scrollWidth;
+      const scrollRatio = oldScrollHeight > 0 ? scrollContainerRef.scrollTop / oldScrollHeight : 0;
+      const scrollLeftRatio =
+        oldScrollWidth > 0 ? scrollContainerRef.scrollLeft / oldScrollWidth : 0;
+
+      // Poll for layout update with bounded timeout
+      let pollStartTime = Date.now();
+      const maxPollTime = 400; // Max 400ms to wait for layout
+
+      function pollForLayoutUpdate() {
+        // Check if we're still the latest adjustment
+        if (currentToken !== zoomAdjustToken) {
+          return; // Stale adjustment, abort
         }
-      });
 
-      if (!targetPage || targetPageNum === null) {
-        // Fallback: use viewport center calculation
-        const oldScrollHeight = scrollContainerRef.scrollHeight;
-        const scrollRatio =
-          oldScrollHeight > 0 ? scrollContainerRef.scrollTop / oldScrollHeight : 0;
+        if (!scrollContainerRef) return;
+
+        const newScrollHeight = scrollContainerRef.scrollHeight;
+        const newScrollWidth = scrollContainerRef.scrollWidth;
+        if (newScrollHeight > 0 && newScrollHeight !== oldScrollHeight) {
+          // Layout has updated
+          scrollContainerRef.scrollTop = scrollRatio * newScrollHeight;
+
+          // Adjust horizontal scroll if container has horizontal overflow
+          if (
+            newScrollWidth > 0 &&
+            newScrollWidth !== oldScrollWidth &&
+            scrollContainerRef.scrollWidth > scrollContainerRef.clientWidth
+          ) {
+            scrollContainerRef.scrollLeft = scrollLeftRatio * newScrollWidth;
+          }
 
-        // Wait for pages to re-render, then adjust scroll
-        setTimeout(() => {
-          if (!scrollContainerRef) return;
-          const newScrollHeight = scrollContainerRef.scrollHeight;
+          zoomOriginPoint = null;
+          zoomOriginScale = null;
+        } else if (Date.now() - pollStartTime < maxPollTime) {
+          // Keep polling
+          scrollAdjustRafId = requestAnimationFrame(pollForLayoutUpdate);
+        } else {
+          // Timeout - apply adjustment anyway
           if (newScrollHeight > 0) {
             scrollContainerRef.scrollTop = scrollRatio * newScrollHeight;
           }
+          if (
+            newScrollWidth > 0 &&
+            scrollContainerRef.scrollWidth > scrollContainerRef.clientWidth
+          ) {
+            scrollContainerRef.scrollLeft = scrollLeftRatio * newScrollWidth;
+          }
           zoomOriginPoint = null;
           zoomOriginScale = null;
-        }, 50);
-        return;
+        }
+      }
+
+      scrollAdjustRafId = requestAnimationFrame(pollForLayoutUpdate);
+      return;
+    }
+
+    // Calculate the ratio of the point's position within the page (both vertical and horizontal)
+    const oldPageHeight = targetPage.offsetHeight;
+    const oldPageWidth = targetPage.offsetWidth;
+    const pointRatio = oldPageHeight > 0 ? pointOffsetFromPageTop / oldPageHeight : 0;
+    const pointRatioX = oldPageWidth > 0 ? pointOffsetFromPageLeft / oldPageWidth : 0;
+
+    // Poll for page dimensions update with bounded timeout
+    let pollStartTime = Date.now();
+    const maxPollTime = 400; // Max 400ms to wait for layout
+
+    function pollForPageHeightUpdate() {
+      // Check if we're still the latest adjustment
+      if (currentToken !== zoomAdjustToken) {
+        return; // Stale adjustment, abort
       }
 
-      // Calculate the ratio of the point's position within the page
-      const oldPageHeight = targetPage.offsetHeight;
-      const pointRatio = oldPageHeight > 0 ? pointOffsetFromPageTop / oldPageHeight : 0;
+      if (!scrollContainerRef || !targetPage) return;
 
-      // Wait a bit more for pages to re-render with new scale
-      // Use a small timeout to ensure canvas rendering has updated page heights
-      setTimeout(() => {
-        if (!scrollContainerRef || !targetPage) return;
+      const newPageHeight = targetPage.offsetHeight;
+      const newPageWidth = targetPage.offsetWidth;
 
-        const newPageHeight = targetPage.offsetHeight;
+      if (newPageHeight !== oldPageHeight && newPageHeight > 0) {
+        // Page dimensions have updated - apply scroll adjustment
         const newPointOffsetFromPageTop = pointRatio * newPageHeight;
         const newPageTop = targetPage.offsetTop;
-        const newPointInContainer = newPageTop + newPointOffsetFromPageTop;
+        const newPointInContainerY = newPageTop + newPointOffsetFromPageTop;
 
-        // Adjust scroll to keep the point at the same screen position
-        const newScrollTop = newPointInContainer - pointY;
+        // Adjust vertical scroll to keep the point at the same screen position
+        const newScrollTop = newPointInContainerY - pointY;
         scrollContainerRef.scrollTop = Math.max(0, newScrollTop);
 
+        // Adjust horizontal scroll if container has horizontal overflow
+        if (scrollContainerRef.scrollWidth > scrollContainerRef.clientWidth) {
+          const newPointOffsetFromPageLeft = pointRatioX * newPageWidth;
+          const newPageLeft = targetPage.offsetLeft;
+          const newPointInContainerX = newPageLeft + newPointOffsetFromPageLeft;
+          const newScrollLeft = newPointInContainerX - pointX;
+          scrollContainerRef.scrollLeft = Math.max(0, newScrollLeft);
+        }
+
         // Clear zoom origin tracking
         zoomOriginPoint = null;
         zoomOriginScale = null;
-      }, 50);
-    });
+      } else if (Date.now() - pollStartTime < maxPollTime) {
+        // Keep polling
+        scrollAdjustRafId = requestAnimationFrame(pollForPageHeightUpdate);
+      } else {
+        // Timeout - apply adjustment with current dimensions anyway
+        if (newPageHeight > 0) {
+          const newPointOffsetFromPageTop = pointRatio * newPageHeight;
+          const newPageTop = targetPage.offsetTop;
+          const newPointInContainerY = newPageTop + newPointOffsetFromPageTop;
+          const newScrollTop = newPointInContainerY - pointY;
+          scrollContainerRef.scrollTop = Math.max(0, newScrollTop);
+
+          // Adjust horizontal scroll if container has horizontal overflow
+          if (scrollContainerRef.scrollWidth > scrollContainerRef.clientWidth && newPageWidth > 0) {
+            const newPointOffsetFromPageLeft = pointRatioX * newPageWidth;
+            const newPageLeft = targetPage.offsetLeft;
+            const newPointInContainerX = newPageLeft + newPointOffsetFromPageLeft;
+            const newScrollLeft = newPointInContainerX - pointX;
+            scrollContainerRef.scrollLeft = Math.max(0, newScrollLeft);
+          }
+        }
+        zoomOriginPoint = null;
+        zoomOriginScale = null;
+      }
+    }
+
+    scrollAdjustRafId = requestAnimationFrame(pollForPageHeightUpdate);
   });
 
   function cleanup() {
diff --git a/packages/web/src/components/mock/MockIndex.jsx b/packages/web/src/components/mock/MockIndex.jsx
new file mode 100644
index 000000000..c2764da2e
--- /dev/null
+++ b/packages/web/src/components/mock/MockIndex.jsx
@@ -0,0 +1,38 @@
+import { A } from '@solidjs/router';
+
+/**
+ * Mock Index - Landing page for visual-only mockups
+ * These are temporary wireframes with no data/logic
+ */
+export default function MockIndex() {
+  return (
+    <div class='mx-auto max-w-4xl px-4 py-12'>
+      <div class='mb-8 rounded-lg border-2 border-amber-200 bg-amber-50 p-4'>
+        <h2 class='mb-2 text-lg font-semibold text-amber-900'>Mock Pages</h2>
+        <p class='text-sm text-amber-800'>
+          These are visual-only wireframes with no data loading, Yjs logic, or backend integration.
+          They are temporary and will not reach production.
+        </p>
+      </div>
+
+      <div class='space-y-4'>
+        <h1 class='text-2xl font-bold text-gray-900'>Available Mocks</h1>
+
+        <div class='grid gap-4'>
+          <A
+            href='/mock/robins-reconcile-section-b-question'
+            class='block rounded-lg border border-gray-200 bg-white p-6 shadow-sm transition-shadow hover:shadow-md'
+          >
+            <h3 class='mb-2 text-lg font-semibold text-gray-900'>
+              ROBINS-I Section B Question Reconcile
+            </h3>
+            <p class='text-sm text-gray-600'>
+              Three-column compare view for a single Section B question with always-visible
+              comments.
+            </p>
+          </A>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/packages/web/src/components/mock/RobinsReconcileSectionBQuestionMock.jsx b/packages/web/src/components/mock/RobinsReconcileSectionBQuestionMock.jsx
new file mode 100644
index 000000000..048bc45b1
--- /dev/null
+++ b/packages/web/src/components/mock/RobinsReconcileSectionBQuestionMock.jsx
@@ -0,0 +1,214 @@
+import { createSignal, For } from 'solid-js';
+import { A } from '@solidjs/router';
+import {
+  SECTION_B,
+  RESPONSE_LABELS,
+} from '@/components/checklist/ROBINSIChecklist/checklist-map.js';
+import { AiOutlineArrowLeft, AiOutlineArrowRight } from 'solid-icons/ai';
+
+/**
+ * Mock component for ROBINS-I Section B question reconciliation
+ * Visual-only wireframe with no data/logic - comments always visible
+ */
+export default function RobinsReconcileSectionBQuestionMock() {
+  // Mock data - hardcoded for visual purposes
+  const questionKey = 'b1';
+  const question = SECTION_B[questionKey];
+  const responseOptions = ['Y', 'PY', 'PN', 'N'];
+
+  // Mock reviewer answers
+  const reviewer1Answer = 'Y';
+  const reviewer2Answer = 'PY';
+  const reviewer1Comment =
+    'Authors used propensity score matching to control for age, sex, and baseline severity.';
+  const reviewer2Comment =
+    'Propensity score matching was used, but some important confounders may have been omitted (e.g., socioeconomic status).';
+
+  // Local state for final answer (visual only)
+  const [finalAnswer, setFinalAnswer] = createSignal(reviewer1Answer);
+  const [finalComment, setFinalComment] = createSignal('');
+
+  const isAgreement = reviewer1Answer === reviewer2Answer;
+
+  return (
+    <div class='min-h-screen bg-blue-50'>
+      <div class='mx-auto max-w-7xl px-4 py-4'>
+        {/* Header */}
+        <div class='mb-4 flex items-center gap-4'>
+          <A
+            href='/mock'
+            class='shrink-0 rounded-lg p-2 transition-colors hover:bg-gray-100'
+            title='Back to mock index'
+          >
+            <AiOutlineArrowLeft class='h-5 w-5 text-gray-600' />
+          </A>
+          <div>
+            <h1 class='text-lg font-bold text-gray-900'>ROBINS-I Reconcile (Mock)</h1>
+            <p class='text-xs text-gray-500'>Visual wireframe only - no data/logic</p>
+          </div>
+        </div>
+
+        {/* Question Card */}
+        <div class='overflow-hidden rounded-lg bg-white shadow-lg'>
+          {/* Question Header */}
+          <div
+            class={`p-4 ${isAgreement ? 'border-b border-green-200 bg-green-50' : 'border-b border-amber-200 bg-amber-50'}`}
+          >
+            <h2 class='text-md font-medium text-gray-900'>
+              <span class='font-semibold'>{questionKey.toUpperCase()}.</span> {question.text}
+            </h2>
+            <div class='mt-2 flex items-center gap-3'>
+              <span
+                class={`text-xs font-medium ${isAgreement ? 'text-green-700' : 'text-amber-700'}`}
+              >
+                {isAgreement ? 'Reviewers Agree' : 'Requires Reconciliation'}
+              </span>
+            </div>
+          </div>
+
+          {/* Three Column Layout */}
+          <div class='grid grid-cols-3 divide-x divide-gray-200'>
+            {/* Reviewer 1 Panel */}
+            <div class='p-4'>
+              <div class='mb-4 flex items-center justify-between'>
+                <h3 class='font-semibold text-gray-900'>Reviewer 1</h3>
+              </div>
+
+              {/* Response Options */}
+              <div class='mb-4 flex flex-wrap gap-2'>
+                <For each={responseOptions}>
+                  {option => (
+                    <div
+                      class={`inline-flex items-center justify-center rounded-lg border-2 px-4 py-2 text-sm font-medium transition-all ${
+                        reviewer1Answer === option ?
+                          'border-blue-400 bg-blue-50 text-blue-800'
+                        : 'border-gray-200 bg-white text-gray-700'
+                      }`}
+                    >
+                      <span class='mr-1'>{option}</span>
+                      <span class='text-xs opacity-70'>({RESPONSE_LABELS[option]})</span>
+                    </div>
+                  )}
+                </For>
+              </div>
+
+              {/* Comment - Always Visible */}
+              <div class='mt-4'>
+                <label class='mb-1 block text-xs font-medium text-gray-700'>Comment</label>
+                <div class='rounded-lg border border-gray-200 bg-gray-50 p-3'>
+                  <p class='text-sm whitespace-pre-wrap text-gray-700'>{reviewer1Comment}</p>
+                </div>
+              </div>
+            </div>
+
+            {/* Reviewer 2 Panel */}
+            <div class='p-4'>
+              <div class='mb-4 flex items-center justify-between'>
+                <h3 class='font-semibold text-gray-900'>Reviewer 2</h3>
+              </div>
+
+              {/* Response Options */}
+              <div class='mb-4 flex flex-wrap gap-2'>
+                <For each={responseOptions}>
+                  {option => (
+                    <div
+                      class={`inline-flex items-center justify-center rounded-lg border-2 px-4 py-2 text-sm font-medium transition-all ${
+                        reviewer2Answer === option ?
+                          'border-purple-400 bg-purple-50 text-purple-800'
+                        : 'border-gray-200 bg-white text-gray-700'
+                      }`}
+                    >
+                      <span class='mr-1'>{option}</span>
+                      <span class='text-xs opacity-70'>({RESPONSE_LABELS[option]})</span>
+                    </div>
+                  )}
+                </For>
+              </div>
+
+              {/* Comment - Always Visible */}
+              <div class='mt-4'>
+                <label class='mb-1 block text-xs font-medium text-gray-700'>Comment</label>
+                <div class='rounded-lg border border-gray-200 bg-gray-50 p-3'>
+                  <p class='text-sm whitespace-pre-wrap text-gray-700'>{reviewer2Comment}</p>
+                </div>
+              </div>
+            </div>
+
+            {/* Final Panel */}
+            <div class='bg-green-50/30 p-4'>
+              <div class='mb-4 flex items-center justify-between'>
+                <h3 class='font-semibold text-gray-900'>Final Answer</h3>
+              </div>
+
+              {/* Response Options - Interactive */}
+              <div class='mb-4 flex flex-wrap gap-2'>
+                <For each={responseOptions}>
+                  {option => (
+                    <label
+                      class={`inline-flex cursor-pointer items-center justify-center rounded-lg border-2 px-4 py-2 text-sm font-medium transition-all focus-within:ring-2 focus-within:ring-green-400 focus-within:ring-offset-1 focus-within:outline-none hover:border-green-300 ${
+                        finalAnswer() === option ?
+                          'border-green-400 bg-green-50 text-green-800'
+                        : 'border-gray-200 bg-white text-gray-700 hover:bg-green-50'
+                      }`}
+                    >
+                      <input
+                        type='radio'
+                        name='final-answer'
+                        value={option}
+                        checked={finalAnswer() === option}
+                        onChange={() => setFinalAnswer(option)}
+                        class='hidden'
+                      />
+                      <span class='mr-1'>{option}</span>
+                      <span class='text-xs opacity-70'>({RESPONSE_LABELS[option]})</span>
+                    </label>
+                  )}
+                </For>
+              </div>
+
+              {/* Comment - Always Visible, Editable */}
+              <div class='mt-4'>
+                <label class='mb-1 block text-xs font-medium text-gray-700'>Final Comment</label>
+                <textarea
+                  value={finalComment()}
+                  onInput={e => setFinalComment(e.target.value)}
+                  placeholder='Add the final reconciled comment...'
+                  class='w-full rounded-lg border border-gray-200 bg-white p-3 text-sm focus:border-green-400 focus:ring-2 focus:ring-green-400 focus:ring-offset-1 focus:outline-none'
+                  rows={4}
+                />
+              </div>
+            </div>
+          </div>
+        </div>
+
+        {/* Navigation Footer */}
+        <div class='mt-4 flex items-center justify-between'>
+          <button
+            disabled
+            class='flex cursor-not-allowed items-center gap-2 rounded-lg bg-gray-100 px-4 py-2 font-medium text-gray-400 transition-colors'
+          >
+            <AiOutlineArrowLeft class='h-4 w-4' />
+            Previous
+          </button>
+
+          <div class='text-sm text-gray-600'>Question 1 of 3</div>
+
+          <button class='flex items-center gap-2 rounded-lg bg-blue-600 px-4 py-2 font-medium text-white shadow transition-colors hover:bg-blue-700'>
+            Next
+            <AiOutlineArrowRight class='h-4 w-4' />
+          </button>
+        </div>
+
+        {/* Action Buttons */}
+        <div class='mt-6 flex items-center justify-end gap-3'>
+          <button class='rounded-lg border border-gray-300 bg-white px-4 py-2 text-sm font-medium text-gray-700 transition-colors hover:bg-gray-50'>
+            Cancel
+          </button>
+          <button class='rounded-lg bg-green-600 px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-green-700'>
+            Finalize Reconciliation
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/packages/web/src/primitives/__tests__/useProject.test.js b/packages/web/src/primitives/__tests__/useProject.test.js
index ad85adcde..e3f7be8a6 100644
--- a/packages/web/src/primitives/__tests__/useProject.test.js
+++ b/packages/web/src/primitives/__tests__/useProject.test.js
@@ -444,6 +444,37 @@ describe('useProject - Checklist Operations', () => {
     });
   });
 
+  it('should persist ROBINS-I manual judgementSource when updating overall section', async () => {
+    await new Promise(resolveTest => {
+      createRoot(async dispose => {
+        cleanup = dispose;
+        const project = useProject('local-test');
+
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        const studyId = project.createStudy('Test Study');
+        const checklistId = project.createChecklist(studyId, 'ROBINS_I');
+
+        project.updateChecklistAnswer(studyId, checklistId, 'overall', {
+          judgement: 'Moderate risk',
+          judgementSource: 'manual',
+          direction: null,
+        });
+
+        // Wait for Y.js update event to trigger sync
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        const checklistData = project.getChecklistData(studyId, checklistId);
+        expect(checklistData).toBeDefined();
+        expect(checklistData.type).toBe('ROBINS_I');
+        expect(checklistData.answers?.overall?.judgementSource).toBe('manual');
+        expect(checklistData.answers?.overall?.judgement).toBe('Moderate risk');
+
+        resolveTest();
+      });
+    });
+  });
+
   it('should get checklist data with answers', async () => {
     createRoot(async dispose => {
       cleanup = dispose;
diff --git a/packages/web/src/primitives/useProject/checklists.js b/packages/web/src/primitives/useProject/checklists.js
deleted file mode 100644
index c4b3d1adb..000000000
--- a/packages/web/src/primitives/useProject/checklists.js
+++ /dev/null
@@ -1,538 +0,0 @@
-/**
- * Checklist operations for useProject
- */
-
-import * as Y from 'yjs';
-import { createChecklistOfType, CHECKLIST_TYPES } from '@/checklist-registry';
-import { CHECKLIST_STATUS } from '@/constants/checklist-status.js';
-
-/**
- * Creates checklist operations
- * @param {string} projectId - The project ID
- * @param {Function} getYDoc - Function that returns the Y.Doc
- * @param {Function} isSynced - Function that returns sync status
- * @returns {Object} Checklist operations
- */
-export function createChecklistOperations(projectId, getYDoc, _isSynced) {
-  /**
-   * Create a checklist in a study
-   * @param {string} studyId - The study ID
-   * @param {string} type - Checklist type (default: 'AMSTAR2')
-   * @param {string|null} assignedTo - User ID to assign to
-   * @returns {string|null} The checklist ID or null if failed
-   */
-  function createChecklist(studyId, type = 'AMSTAR2', assignedTo = null) {
-    const ydoc = getYDoc();
-    if (!ydoc) return null;
-
-    const studiesMap = ydoc.getMap('reviews');
-    const studyYMap = studiesMap.get(studyId);
-
-    if (!studyYMap) return null;
-
-    let checklistsMap = studyYMap.get('checklists');
-    if (!checklistsMap) {
-      checklistsMap = new Y.Map();
-      studyYMap.set('checklists', checklistsMap);
-    }
-
-    const checklistId = crypto.randomUUID();
-    const now = Date.now();
-
-    // Get the default answers structure for this checklist type using the registry
-    let answersData = {};
-    const checklistTemplate = createChecklistOfType(type, {
-      id: checklistId,
-      name: `${type} Checklist`,
-      createdAt: now,
-    });
-
-    // Extract answers based on checklist type
-    if (type === CHECKLIST_TYPES.AMSTAR2) {
-      // AMSTAR2: Extract question answers (q1, q2, etc.)
-      Object.entries(checklistTemplate).forEach(([key, value]) => {
-        if (/^q\d+[a-z]*$/i.test(key)) {
-          answersData[key] = value;
-        }
-      });
-    } else if (type === CHECKLIST_TYPES.ROBINS_I) {
-      // ROBINS-I: Extract all domain and section data
-      const robinsKeys = [
-        'planning',
-        'sectionA',
-        'sectionB',
-        'sectionC',
-        'sectionD',
-        'confoundingEvaluation',
-        'domain1a',
-        'domain1b',
-        'domain2',
-        'domain3',
-        'domain4',
-        'domain5',
-        'domain6',
-        'overall',
-      ];
-      robinsKeys.forEach(key => {
-        if (checklistTemplate[key] !== undefined) {
-          answersData[key] = checklistTemplate[key];
-        }
-      });
-    }
-
-    const checklistYMap = new Y.Map();
-    checklistYMap.set('type', type);
-    checklistYMap.set('title', `${type} Checklist`);
-    checklistYMap.set('assignedTo', assignedTo);
-    checklistYMap.set('status', CHECKLIST_STATUS.PENDING);
-    checklistYMap.set('createdAt', now);
-    checklistYMap.set('updatedAt', now);
-
-    // Store answers as a Y.Map
-    const answersYMap = new Y.Map();
-    // Add answersYMap to checklistYMap early so it's part of the document structure
-    // This prevents Yjs errors when accessing the map
-    checklistYMap.set('answers', answersYMap);
-
-    if (type === CHECKLIST_TYPES.AMSTAR2) {
-      // AMSTAR2: Store each question as a nested Y.Map with answers, critical, and note
-      // Note: q9 and q11 are multi-part questions (q9a/q9b, q11a/q11b) but get one note each
-      // at the parent level (q9, q11)
-      const multiPartParents = ['q9', 'q11'];
-      const subQuestionPattern = /^(q9|q11)[a-z]$/;
-
-      // Track which keys we've added to avoid checking with .has() before map is in document
-      const addedKeys = new Set();
-
-      Object.entries(answersData).forEach(([questionKey, questionData]) => {
-        const questionYMap = new Y.Map();
-        questionYMap.set('answers', questionData.answers);
-        questionYMap.set('critical', questionData.critical);
-
-        // Add note for non-sub-questions
-        // Sub-questions (q9a, q9b, q11a, q11b) don't get notes - the parent does
-        if (!subQuestionPattern.test(questionKey)) {
-          questionYMap.set('note', new Y.Text());
-        }
-
-        answersYMap.set(questionKey, questionYMap);
-        addedKeys.add(questionKey);
-      });
-
-      // Add note entries for multi-part parent questions (q9, q11)
-      // These don't have answer data but need a note
-      multiPartParents.forEach(parentKey => {
-        if (!addedKeys.has(parentKey)) {
-          const parentYMap = new Y.Map();
-          parentYMap.set('note', new Y.Text());
-          answersYMap.set(parentKey, parentYMap);
-        }
-      });
-    } else if (type === CHECKLIST_TYPES.ROBINS_I) {
-      // ROBINS-I: Store each section/domain as nested Y.Maps to support concurrent edits
-      Object.entries(answersData).forEach(([key, value]) => {
-        const sectionYMap = new Y.Map();
-
-        // Domain keys have nested 'answers' object with individual questions
-        if (key.startsWith('domain') || key === 'overall') {
-          // Store judgement and direction at section level
-          sectionYMap.set('judgement', value.judgement ?? null);
-          if (value.direction !== undefined) {
-            sectionYMap.set('direction', value.direction ?? null);
-          }
-
-          // Store each question as a nested Y.Map for concurrent edits
-          if (value.answers) {
-            const answersNestedYMap = new Y.Map();
-            Object.entries(value.answers).forEach(([qKey, qValue]) => {
-              const questionYMap = new Y.Map();
-              questionYMap.set('answer', qValue.answer ?? null);
-              questionYMap.set('comment', qValue.comment ?? '');
-              answersNestedYMap.set(qKey, questionYMap);
-            });
-            sectionYMap.set('answers', answersNestedYMap);
-          }
-        } else if (key === 'sectionB') {
-          // Section B has individual questions (b1, b2, b3) and stopAssessment
-          Object.entries(value).forEach(([subKey, subValue]) => {
-            if (typeof subValue === 'object' && subValue !== null) {
-              const questionYMap = new Y.Map();
-              questionYMap.set('answer', subValue.answer ?? null);
-              questionYMap.set('comment', subValue.comment ?? '');
-              sectionYMap.set(subKey, questionYMap);
-            } else {
-              sectionYMap.set(subKey, subValue);
-            }
-          });
-        } else if (key === 'confoundingEvaluation') {
-          // Confounding evaluation has arrays - store as JSON for now
-          sectionYMap.set('predefined', value.predefined ?? []);
-          sectionYMap.set('additional', value.additional ?? []);
-        } else if (key === 'sectionD') {
-          // Section D has sources object and otherSpecify
-          sectionYMap.set('sources', value.sources ?? {});
-          sectionYMap.set('otherSpecify', value.otherSpecify ?? '');
-        } else {
-          // Other sections (planning, sectionA, sectionC): store each field
-          Object.entries(value).forEach(([fieldKey, fieldValue]) => {
-            sectionYMap.set(fieldKey, fieldValue);
-          });
-        }
-
-        answersYMap.set(key, sectionYMap);
-      });
-    } else {
-      // Other types: Store data directly (will be serialized as JSON)
-      Object.entries(answersData).forEach(([key, value]) => {
-        answersYMap.set(key, value);
-      });
-    }
-
-    checklistsMap.set(checklistId, checklistYMap);
-
-    // Update study's updatedAt
-    studyYMap.set('updatedAt', now);
-
-    return checklistId;
-  }
-
-  /**
-   * Update a checklist
-   * @param {string} studyId - The study ID
-   * @param {string} checklistId - The checklist ID
-   * @param {Object} updates - Fields to update
-   */
-  function updateChecklist(studyId, checklistId, updates) {
-    const ydoc = getYDoc();
-    if (!ydoc) return;
-
-    const studiesMap = ydoc.getMap('reviews');
-    const studyYMap = studiesMap.get(studyId);
-    if (!studyYMap) return;
-
-    const checklistsMap = studyYMap.get('checklists');
-    if (!checklistsMap) return;
-
-    const checklistYMap = checklistsMap.get(checklistId);
-    if (!checklistYMap) return;
-
-    if (updates.title !== undefined) checklistYMap.set('title', updates.title);
-    if (updates.assignedTo !== undefined) checklistYMap.set('assignedTo', updates.assignedTo);
-    if (updates.status !== undefined) checklistYMap.set('status', updates.status);
-    checklistYMap.set('updatedAt', Date.now());
-  }
-
-  /**
-   * Delete a checklist
-   * @param {string} studyId - The study ID
-   * @param {string} checklistId - The checklist ID
-   */
-  function deleteChecklist(studyId, checklistId) {
-    const ydoc = getYDoc();
-    if (!ydoc) return;
-
-    const studiesMap = ydoc.getMap('reviews');
-    const studyYMap = studiesMap.get(studyId);
-    if (!studyYMap) return;
-
-    const checklistsMap = studyYMap.get('checklists');
-    if (!checklistsMap) return;
-
-    checklistsMap.delete(checklistId);
-    studyYMap.set('updatedAt', Date.now());
-  }
-
-  /**
-   * Get a specific checklist's Y.Map for answer updates
-   * @param {string} studyId - The study ID
-   * @param {string} checklistId - The checklist ID
-   * @returns {Y.Map|null} The answers Y.Map or null
-   */
-  function getChecklistAnswersMap(studyId, checklistId) {
-    const ydoc = getYDoc();
-    if (!ydoc) return null;
-
-    const studiesMap = ydoc.getMap('reviews');
-    const studyYMap = studiesMap.get(studyId);
-    if (!studyYMap) return null;
-
-    const checklistsMap = studyYMap.get('checklists');
-    if (!checklistsMap) return null;
-
-    const checklistYMap = checklistsMap.get(checklistId);
-    if (!checklistYMap) return null;
-
-    return checklistYMap.get('answers');
-  }
-
-  /**
-   * Get full checklist data including answers in plain object format
-   * @param {string} studyId - The study ID
-   * @param {string} checklistId - The checklist ID
-   * @returns {Object|null} The checklist data or null
-   */
-  function getChecklistData(studyId, checklistId) {
-    const ydoc = getYDoc();
-    if (!ydoc) return null;
-
-    const studiesMap = ydoc.getMap('reviews');
-    const studyYMap = studiesMap.get(studyId);
-    if (!studyYMap) return null;
-
-    const checklistsMap = studyYMap.get('checklists');
-    if (!checklistsMap) return null;
-
-    const checklistYMap = checklistsMap.get(checklistId);
-    if (!checklistYMap) return null;
-
-    const data = checklistYMap.toJSON ? checklistYMap.toJSON() : {};
-    const checklistType = checklistYMap.get('type');
-
-    // Convert answers Y.Map to plain object with question keys at top level
-    const answers = {};
-    const answersMap = checklistYMap.get('answers');
-    if (answersMap && typeof answersMap.entries === 'function') {
-      for (const [key, sectionYMap] of answersMap.entries()) {
-        // ROBINS-I: Reconstruct nested structure from Y.Maps
-        if (checklistType === 'ROBINS_I' && sectionYMap instanceof Y.Map) {
-          if (key.startsWith('domain')) {
-            const sectionData = {
-              judgement: sectionYMap.get('judgement') ?? null,
-              answers: {}, // Always initialize answers for domains
-            };
-            const direction = sectionYMap.get('direction');
-            if (direction !== undefined) {
-              sectionData.direction = direction;
-            }
-
-            // Reconstruct nested answers
-            const answersNestedYMap = sectionYMap.get('answers');
-            if (answersNestedYMap instanceof Y.Map) {
-              for (const [qKey, questionYMap] of answersNestedYMap.entries()) {
-                if (questionYMap instanceof Y.Map) {
-                  sectionData.answers[qKey] = {
-                    answer: questionYMap.get('answer') ?? null,
-                    comment: questionYMap.get('comment') ?? '',
-                  };
-                } else {
-                  sectionData.answers[qKey] = questionYMap;
-                }
-              }
-            }
-            answers[key] = sectionData;
-          } else if (key === 'overall') {
-            // Overall section has judgement and direction but no nested answers
-            const sectionData = {
-              judgement: sectionYMap.get('judgement') ?? null,
-            };
-            const direction = sectionYMap.get('direction');
-            if (direction !== undefined) {
-              sectionData.direction = direction;
-            }
-            answers[key] = sectionData;
-          } else if (key === 'sectionB') {
-            const sectionData = {};
-            for (const [subKey, subValue] of sectionYMap.entries()) {
-              if (subValue instanceof Y.Map) {
-                sectionData[subKey] = {
-                  answer: subValue.get('answer') ?? null,
-                  comment: subValue.get('comment') ?? '',
-                };
-              } else {
-                sectionData[subKey] = subValue;
-              }
-            }
-            answers[key] = sectionData;
-          } else {
-            // Other sections: convert Y.Map to plain object
-            answers[key] = sectionYMap.toJSON ? sectionYMap.toJSON() : sectionYMap;
-          }
-        } else {
-          // AMSTAR2 and other types
-          const sectionData = sectionYMap.toJSON ? sectionYMap.toJSON() : sectionYMap;
-          answers[key] = sectionData;
-        }
-      }
-    }
-
-    return {
-      ...data,
-      answers,
-    };
-  }
-
-  /**
-   * Update a single answer/section in a checklist
-   * @param {string} studyId - The study ID
-   * @param {string} checklistId - The checklist ID
-   * @param {string} key - The answer key (e.g., 'q1' for AMSTAR2, 'domain1a' for ROBINS-I)
-   * @param {Object} data - The answer data (structure depends on checklist type)
-   */
-  function updateChecklistAnswer(studyId, checklistId, key, data) {
-    const ydoc = getYDoc();
-    if (!ydoc) return;
-
-    const studiesMap = ydoc.getMap('reviews');
-    const studyYMap = studiesMap.get(studyId);
-    if (!studyYMap) return;
-
-    const checklistsMap = studyYMap.get('checklists');
-    if (!checklistsMap) return;
-
-    const checklistYMap = checklistsMap.get(checklistId);
-    if (!checklistYMap) return;
-
-    let answersMap = checklistYMap.get('answers');
-    if (!answersMap) {
-      answersMap = new Y.Map();
-      checklistYMap.set('answers', answersMap);
-    }
-
-    const checklistType = checklistYMap.get('type');
-
-    // AMSTAR2: Store as nested Y.Map with answers and critical (preserving existing note)
-    if (checklistType === 'AMSTAR2' && data.answers !== undefined) {
-      let questionYMap = answersMap.get(key);
-      if (!questionYMap || !(questionYMap instanceof Y.Map)) {
-        questionYMap = new Y.Map();
-        answersMap.set(key, questionYMap);
-      }
-      questionYMap.set('answers', data.answers);
-      questionYMap.set('critical', data.critical);
-      // Note: Y.Text note is preserved - we don't overwrite it here
-      // If no note exists yet, create one (for existing checklists without notes)
-      if (!questionYMap.get('note')) {
-        questionYMap.set('note', new Y.Text());
-      }
-    }
-    // ROBINS-I: Update nested Y.Maps granularly for concurrent edit support
-    else if (checklistType === 'ROBINS_I') {
-      let sectionYMap = answersMap.get(key);
-
-      // Create section Y.Map if it doesn't exist
-      if (!sectionYMap || !(sectionYMap instanceof Y.Map)) {
-        sectionYMap = new Y.Map();
-        answersMap.set(key, sectionYMap);
-      }
-
-      // Domain keys have nested 'answers' object with individual questions
-      if (key.startsWith('domain') || key === 'overall') {
-        // Update judgement and direction at section level
-        if (data.judgement !== undefined) {
-          sectionYMap.set('judgement', data.judgement);
-        }
-        if (data.direction !== undefined) {
-          sectionYMap.set('direction', data.direction);
-        }
-
-        // Update individual questions in answers
-        if (data.answers) {
-          let answersNestedYMap = sectionYMap.get('answers');
-          if (!answersNestedYMap || !(answersNestedYMap instanceof Y.Map)) {
-            answersNestedYMap = new Y.Map();
-            sectionYMap.set('answers', answersNestedYMap);
-          }
-
-          Object.entries(data.answers).forEach(([qKey, qValue]) => {
-            let questionYMap = answersNestedYMap.get(qKey);
-            if (!questionYMap || !(questionYMap instanceof Y.Map)) {
-              questionYMap = new Y.Map();
-              answersNestedYMap.set(qKey, questionYMap);
-            }
-            if (qValue.answer !== undefined) questionYMap.set('answer', qValue.answer);
-            if (qValue.comment !== undefined) questionYMap.set('comment', qValue.comment);
-          });
-        }
-      } else if (key === 'sectionB') {
-        // Section B: update individual questions or stopAssessment
-        Object.entries(data).forEach(([subKey, subValue]) => {
-          if (typeof subValue === 'object' && subValue !== null) {
-            let questionYMap = sectionYMap.get(subKey);
-            if (!questionYMap || !(questionYMap instanceof Y.Map)) {
-              questionYMap = new Y.Map();
-              sectionYMap.set(subKey, questionYMap);
-            }
-            if (subValue.answer !== undefined) questionYMap.set('answer', subValue.answer);
-            if (subValue.comment !== undefined) questionYMap.set('comment', subValue.comment);
-          } else {
-            sectionYMap.set(subKey, subValue);
-          }
-        });
-      } else if (key === 'confoundingEvaluation') {
-        // Confounding evaluation: update arrays
-        if (data.predefined !== undefined) sectionYMap.set('predefined', data.predefined);
-        if (data.additional !== undefined) sectionYMap.set('additional', data.additional);
-      } else if (key === 'sectionD') {
-        // Section D: update sources or otherSpecify
-        if (data.sources !== undefined) sectionYMap.set('sources', data.sources);
-        if (data.otherSpecify !== undefined) sectionYMap.set('otherSpecify', data.otherSpecify);
-      } else {
-        // Other sections: update individual fields
-        Object.entries(data).forEach(([fieldKey, fieldValue]) => {
-          sectionYMap.set(fieldKey, fieldValue);
-        });
-      }
-    }
-    // Other types: Store data directly
-    else {
-      answersMap.set(key, data);
-    }
-
-    // Auto-transition status from 'pending' to 'in-progress' on first edit
-    const currentStatus = checklistYMap.get('status');
-    if (currentStatus === CHECKLIST_STATUS.PENDING) {
-      checklistYMap.set('status', CHECKLIST_STATUS.IN_PROGRESS);
-    }
-
-    checklistYMap.set('updatedAt', Date.now());
-  }
-
-  /**
-   * Get a Y.Text reference for a question's note (for direct binding)
-   * @param {string} studyId - The study ID
-   * @param {string} checklistId - The checklist ID
-   * @param {string} questionKey - The question key (e.g., 'q1', 'q9' for multi-part)
-   * @returns {Y.Text|null} The Y.Text reference or null
-   */
-  function getQuestionNote(studyId, checklistId, questionKey) {
-    const ydoc = getYDoc();
-    if (!ydoc) return null;
-
-    const studiesMap = ydoc.getMap('reviews');
-    const studyYMap = studiesMap.get(studyId);
-    if (!studyYMap) return null;
-
-    const checklistsMap = studyYMap.get('checklists');
-    if (!checklistsMap) return null;
-
-    const checklistYMap = checklistsMap.get(checklistId);
-    if (!checklistYMap) return null;
-
-    const answersMap = checklistYMap.get('answers');
-    if (!answersMap) return null;
-
-    const questionYMap = answersMap.get(questionKey);
-    if (!questionYMap || !(questionYMap instanceof Y.Map)) return null;
-
-    const note = questionYMap.get('note');
-    // Return existing note, or create one if missing (for existing checklists)
-    if (note instanceof Y.Text) {
-      return note;
-    }
-
-    // Create note if it doesn't exist (backward compatibility)
-    const newNote = new Y.Text();
-    questionYMap.set('note', newNote);
-    return newNote;
-  }
-
-  return {
-    createChecklist,
-    updateChecklist,
-    deleteChecklist,
-    getChecklistAnswersMap,
-    getChecklistData,
-    updateChecklistAnswer,
-    getQuestionNote,
-  };
-}
diff --git a/packages/web/src/primitives/useProject/checklists/common.js b/packages/web/src/primitives/useProject/checklists/common.js
new file mode 100644
index 000000000..cceb18a67
--- /dev/null
+++ b/packages/web/src/primitives/useProject/checklists/common.js
@@ -0,0 +1,112 @@
+/**
+ * Common checklist operations shared across all checklist types
+ */
+
+import * as Y from 'yjs';
+
+/**
+ * Create shared checklist operations that work with any checklist type
+ * @param {Function} getYDoc - Function that returns the Y.Doc
+ * @returns {Object} Common operations
+ */
+export function createCommonOperations(getYDoc) {
+  /**
+   * Update a checklist's metadata
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   * @param {Object} updates - Fields to update (title, assignedTo, status)
+   */
+  function updateChecklist(studyId, checklistId, updates) {
+    const ydoc = getYDoc();
+    if (!ydoc) return;
+
+    const studiesMap = ydoc.getMap('reviews');
+    const studyYMap = studiesMap.get(studyId);
+    if (!studyYMap) return;
+
+    const checklistsMap = studyYMap.get('checklists');
+    if (!checklistsMap) return;
+
+    const checklistYMap = checklistsMap.get(checklistId);
+    if (!checklistYMap) return;
+
+    if (updates.title !== undefined) checklistYMap.set('title', updates.title);
+    if (updates.assignedTo !== undefined) checklistYMap.set('assignedTo', updates.assignedTo);
+    if (updates.status !== undefined) checklistYMap.set('status', updates.status);
+    checklistYMap.set('updatedAt', Date.now());
+  }
+
+  /**
+   * Delete a checklist
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   */
+  function deleteChecklist(studyId, checklistId) {
+    const ydoc = getYDoc();
+    if (!ydoc) return;
+
+    const studiesMap = ydoc.getMap('reviews');
+    const studyYMap = studiesMap.get(studyId);
+    if (!studyYMap) return;
+
+    const checklistsMap = studyYMap.get('checklists');
+    if (!checklistsMap) return;
+
+    checklistsMap.delete(checklistId);
+    studyYMap.set('updatedAt', Date.now());
+  }
+
+  /**
+   * Get a specific checklist's Y.Map for answer updates
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   * @returns {Y.Map|null} The answers Y.Map or null
+   */
+  function getChecklistAnswersMap(studyId, checklistId) {
+    const ydoc = getYDoc();
+    if (!ydoc) return null;
+
+    const studiesMap = ydoc.getMap('reviews');
+    const studyYMap = studiesMap.get(studyId);
+    if (!studyYMap) return null;
+
+    const checklistsMap = studyYMap.get('checklists');
+    if (!checklistsMap) return null;
+
+    const checklistYMap = checklistsMap.get(checklistId);
+    if (!checklistYMap) return null;
+
+    return checklistYMap.get('answers');
+  }
+
+  /**
+   * Get a checklist's Y.Map and type
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   * @returns {{checklistYMap: Y.Map, checklistType: string}|null} The checklist Y.Map and type or null
+   */
+  function getChecklistYMap(studyId, checklistId) {
+    const ydoc = getYDoc();
+    if (!ydoc) return null;
+
+    const studiesMap = ydoc.getMap('reviews');
+    const studyYMap = studiesMap.get(studyId);
+    if (!studyYMap) return null;
+
+    const checklistsMap = studyYMap.get('checklists');
+    if (!checklistsMap) return null;
+
+    const checklistYMap = checklistsMap.get(checklistId);
+    if (!checklistYMap) return null;
+
+    const checklistType = checklistYMap.get('type');
+    return { checklistYMap, checklistType };
+  }
+
+  return {
+    updateChecklist,
+    deleteChecklist,
+    getChecklistAnswersMap,
+    getChecklistYMap,
+  };
+}
diff --git a/packages/web/src/primitives/useProject/checklists/handlers/amstar2.js b/packages/web/src/primitives/useProject/checklists/handlers/amstar2.js
new file mode 100644
index 000000000..e781b075b
--- /dev/null
+++ b/packages/web/src/primitives/useProject/checklists/handlers/amstar2.js
@@ -0,0 +1,146 @@
+/**
+ * AMSTAR2 checklist type handler
+ */
+
+import * as Y from 'yjs';
+import { ChecklistHandler } from './base.js';
+
+export class AMSTAR2Handler extends ChecklistHandler {
+  /**
+   * Extract answer structure from AMSTAR2 checklist template
+   * @param {Object} template - The checklist template from createChecklistOfType
+   * @returns {Object} Extracted answers data structure
+   */
+  extractAnswersFromTemplate(template) {
+    const answersData = {};
+    // AMSTAR2: Extract question answers (q1, q2, etc.)
+    Object.entries(template).forEach(([key, value]) => {
+      if (/^q\d+[a-z]*$/i.test(key)) {
+        answersData[key] = value;
+      }
+    });
+    return answersData;
+  }
+
+  /**
+   * Create Y.Map structure for AMSTAR2 answers
+   * @param {Object} answersData - The extracted answers data
+   * @returns {Y.Map} The answers Y.Map
+   */
+  createAnswersYMap(answersData) {
+    const answersYMap = new Y.Map();
+
+    // AMSTAR2: Store each question as a nested Y.Map with answers, critical, and note
+    // Note: q9 and q11 are multi-part questions (q9a/q9b, q11a/q11b) but get one note each
+    // at the parent level (q9, q11)
+    const multiPartParents = ['q9', 'q11'];
+    const subQuestionPattern = /^(q9|q11)[a-z]$/;
+
+    // Track which keys we've added to avoid checking with .has() before map is in document
+    const addedKeys = new Set();
+
+    Object.entries(answersData).forEach(([questionKey, questionData]) => {
+      const questionYMap = new Y.Map();
+      questionYMap.set('answers', questionData.answers);
+      questionYMap.set('critical', questionData.critical);
+
+      // Add note for non-sub-questions
+      // Sub-questions (q9a, q9b, q11a, q11b) don't get notes - the parent does
+      if (!subQuestionPattern.test(questionKey)) {
+        questionYMap.set('note', new Y.Text());
+      }
+
+      answersYMap.set(questionKey, questionYMap);
+      addedKeys.add(questionKey);
+    });
+
+    // Add note entries for multi-part parent questions (q9, q11)
+    // These don't have answer data but need a note
+    multiPartParents.forEach(parentKey => {
+      if (!addedKeys.has(parentKey)) {
+        const parentYMap = new Y.Map();
+        parentYMap.set('note', new Y.Text());
+        answersYMap.set(parentKey, parentYMap);
+      }
+    });
+
+    return answersYMap;
+  }
+
+  /**
+   * Serialize AMSTAR2 answers Y.Map to plain object
+   * @param {Y.Map} answersMap - The answers Y.Map
+   * @returns {Object} Plain object with answers
+   */
+  serializeAnswers(answersMap) {
+    const answers = {};
+    for (const [key, sectionYMap] of answersMap.entries()) {
+      // AMSTAR2: Simple toJSON conversion
+      const sectionData = sectionYMap.toJSON ? sectionYMap.toJSON() : sectionYMap;
+      answers[key] = sectionData;
+    }
+    return answers;
+  }
+
+  /**
+   * Update a single answer in AMSTAR2 checklist
+   * @param {Y.Map} answersMap - The answers Y.Map
+   * @param {string} key - The question key (e.g., 'q1')
+   * @param {Object} data - The answer data { answers, critical }
+   */
+  updateAnswer(answersMap, key, data) {
+    if (data.answers !== undefined) {
+      let questionYMap = answersMap.get(key);
+      if (!questionYMap || !(questionYMap instanceof Y.Map)) {
+        questionYMap = new Y.Map();
+        answersMap.set(key, questionYMap);
+      }
+      questionYMap.set('answers', data.answers);
+      questionYMap.set('critical', data.critical);
+      // Note: Y.Text note is preserved - we don't overwrite it here
+      // If no note exists yet, create one (for existing checklists without notes)
+      if (!questionYMap.get('note')) {
+        questionYMap.set('note', new Y.Text());
+      }
+    }
+  }
+
+  /**
+   * Get type-specific text getter function for AMSTAR2
+   * @param {Function} getYDoc - Function that returns the Y.Doc
+   * @returns {Function} getQuestionNote function
+   */
+  getTextGetter(getYDoc) {
+    return (studyId, checklistId, questionKey) => {
+      const ydoc = getYDoc();
+      if (!ydoc) return null;
+
+      const studiesMap = ydoc.getMap('reviews');
+      const studyYMap = studiesMap.get(studyId);
+      if (!studyYMap) return null;
+
+      const checklistsMap = studyYMap.get('checklists');
+      if (!checklistsMap) return null;
+
+      const checklistYMap = checklistsMap.get(checklistId);
+      if (!checklistYMap) return null;
+
+      const answersMap = checklistYMap.get('answers');
+      if (!answersMap) return null;
+
+      const questionYMap = answersMap.get(questionKey);
+      if (!questionYMap || !(questionYMap instanceof Y.Map)) return null;
+
+      const note = questionYMap.get('note');
+      // Return existing note, or create one if missing (for existing checklists)
+      if (note instanceof Y.Text) {
+        return note;
+      }
+
+      // Create note if it doesn't exist (backward compatibility)
+      const newNote = new Y.Text();
+      questionYMap.set('note', newNote);
+      return newNote;
+    };
+  }
+}
diff --git a/packages/web/src/primitives/useProject/checklists/handlers/base.js b/packages/web/src/primitives/useProject/checklists/handlers/base.js
new file mode 100644
index 000000000..87154566a
--- /dev/null
+++ b/packages/web/src/primitives/useProject/checklists/handlers/base.js
@@ -0,0 +1,70 @@
+/**
+ * Base handler interface for checklist type-specific operations
+ *
+ * All checklist type handlers must implement these methods.
+ */
+
+import * as Y from 'yjs';
+
+/**
+ * Base handler class that defines the interface for checklist type handlers
+ */
+export class ChecklistHandler {
+  /**
+   * Extract answer structure from checklist template
+   * @param {Object} template - The checklist template from createChecklistOfType
+   * @returns {Object} Extracted answers data structure
+   */
+  extractAnswersFromTemplate(template) {
+    throw new Error('extractAnswersFromTemplate must be implemented by subclass');
+  }
+
+  /**
+   * Create Y.Map structure for answers from extracted data
+   * @param {Object} answersData - The extracted answers data
+   * @returns {Y.Map} The answers Y.Map
+   */
+  createAnswersYMap(answersData) {
+    throw new Error('createAnswersYMap must be implemented by subclass');
+  }
+
+  /**
+   * Serialize answers Y.Map to plain object
+   * @param {Y.Map} answersMap - The answers Y.Map
+   * @returns {Object} Plain object with answers
+   */
+  serializeAnswers(answersMap) {
+    throw new Error('serializeAnswers must be implemented by subclass');
+  }
+
+  /**
+   * Update a single answer/section in the answers Y.Map
+   * @param {Y.Map} answersMap - The answers Y.Map
+   * @param {string} key - The answer key (e.g., 'q1' for AMSTAR2, 'domain1a' for ROBINS-I)
+   * @param {Object} data - The answer data
+   */
+  updateAnswer(answersMap, key, data) {
+    throw new Error('updateAnswer must be implemented by subclass');
+  }
+
+  /**
+   * Get type-specific text getter function
+   * @param {Function} getYDoc - Function that returns the Y.Doc
+   * @returns {Function|null} Text getter function or null if not applicable
+   */
+  getTextGetter(getYDoc) {
+    return null; // Optional - defaults to null
+  }
+}
+
+/**
+ * Helper to convert Y.Text to string safely
+ * @param {*} value - Value that might be Y.Text
+ * @returns {string} String representation
+ */
+export function yTextToString(value) {
+  if (value instanceof Y.Text) {
+    return value.toString();
+  }
+  return value ?? '';
+}
diff --git a/packages/web/src/primitives/useProject/checklists/handlers/robins-i.js b/packages/web/src/primitives/useProject/checklists/handlers/robins-i.js
new file mode 100644
index 000000000..83387fa96
--- /dev/null
+++ b/packages/web/src/primitives/useProject/checklists/handlers/robins-i.js
@@ -0,0 +1,378 @@
+/**
+ * ROBINS-I checklist type handler
+ */
+
+import * as Y from 'yjs';
+import { ChecklistHandler, yTextToString } from './base.js';
+
+export class ROBINSIHandler extends ChecklistHandler {
+  /**
+   * Extract answer structure from ROBINS-I checklist template
+   * @param {Object} template - The checklist template from createChecklistOfType
+   * @returns {Object} Extracted answers data structure
+   */
+  extractAnswersFromTemplate(template) {
+    const answersData = {};
+    // ROBINS-I: Extract all domain and section data
+    const robinsKeys = [
+      'planning',
+      'sectionA',
+      'sectionB',
+      'sectionC',
+      'sectionD',
+      'confoundingEvaluation',
+      'domain1a',
+      'domain1b',
+      'domain2',
+      'domain3',
+      'domain4',
+      'domain5',
+      'domain6',
+      'overall',
+    ];
+    robinsKeys.forEach(key => {
+      if (template[key] !== undefined) {
+        answersData[key] = template[key];
+      }
+    });
+    return answersData;
+  }
+
+  /**
+   * Create Y.Map structure for ROBINS-I answers
+   * @param {Object} answersData - The extracted answers data
+   * @returns {Y.Map} The answers Y.Map
+   */
+  createAnswersYMap(answersData) {
+    const answersYMap = new Y.Map();
+
+    // ROBINS-I: Store each section/domain as nested Y.Maps to support concurrent edits
+    Object.entries(answersData).forEach(([key, value]) => {
+      const sectionYMap = new Y.Map();
+
+      // Domain keys have nested 'answers' object with individual questions
+      if (key.startsWith('domain') || key === 'overall') {
+        // Store judgement and direction at section level
+        sectionYMap.set('judgement', value.judgement ?? null);
+        sectionYMap.set('judgementSource', value.judgementSource ?? 'auto');
+        if (value.direction !== undefined) {
+          sectionYMap.set('direction', value.direction ?? null);
+        }
+
+        // Store each question as a nested Y.Map for concurrent edits
+        if (value.answers) {
+          const answersNestedYMap = new Y.Map();
+          Object.entries(value.answers).forEach(([qKey, qValue]) => {
+            const questionYMap = new Y.Map();
+            questionYMap.set('answer', qValue.answer ?? null);
+            questionYMap.set('comment', new Y.Text());
+            answersNestedYMap.set(qKey, questionYMap);
+          });
+          sectionYMap.set('answers', answersNestedYMap);
+        }
+      } else if (key === 'sectionB') {
+        // Section B has individual questions (b1, b2, b3) and stopAssessment
+        Object.entries(value).forEach(([subKey, subValue]) => {
+          if (typeof subValue === 'object' && subValue !== null) {
+            const questionYMap = new Y.Map();
+            questionYMap.set('answer', subValue.answer ?? null);
+            questionYMap.set('comment', new Y.Text());
+            sectionYMap.set(subKey, questionYMap);
+          } else {
+            sectionYMap.set(subKey, subValue);
+          }
+        });
+      } else if (key === 'confoundingEvaluation') {
+        // Confounding evaluation has arrays - store as JSON for now
+        sectionYMap.set('predefined', value.predefined ?? []);
+        sectionYMap.set('additional', value.additional ?? []);
+      } else if (key === 'sectionD') {
+        // Section D has sources object and otherSpecify
+        sectionYMap.set('sources', value.sources ?? {});
+        sectionYMap.set('otherSpecify', new Y.Text());
+      } else if (key === 'planning') {
+        // Planning section: confoundingFactors is free text
+        sectionYMap.set('confoundingFactors', new Y.Text());
+      } else if (key === 'sectionA') {
+        // Section A: numericalResult, furtherDetails, outcome are free text
+        sectionYMap.set('numericalResult', new Y.Text());
+        sectionYMap.set('furtherDetails', new Y.Text());
+        sectionYMap.set('outcome', new Y.Text());
+      } else if (key === 'sectionC') {
+        // Section C: participants, interventionStrategy, comparatorStrategy are free text
+        sectionYMap.set('participants', new Y.Text());
+        sectionYMap.set('interventionStrategy', new Y.Text());
+        sectionYMap.set('comparatorStrategy', new Y.Text());
+        sectionYMap.set('isPerProtocol', value.isPerProtocol ?? false);
+      } else {
+        // Other sections: store each field
+        Object.entries(value).forEach(([fieldKey, fieldValue]) => {
+          sectionYMap.set(fieldKey, fieldValue);
+        });
+      }
+
+      answersYMap.set(key, sectionYMap);
+    });
+
+    return answersYMap;
+  }
+
+  /**
+   * Serialize ROBINS-I answers Y.Map to plain object
+   * @param {Y.Map} answersMap - The answers Y.Map
+   * @returns {Object} Plain object with answers
+   */
+  serializeAnswers(answersMap) {
+    const answers = {};
+    for (const [key, sectionYMap] of answersMap.entries()) {
+      if (!(sectionYMap instanceof Y.Map)) {
+        answers[key] = sectionYMap;
+        continue;
+      }
+
+      if (key.startsWith('domain')) {
+        const sectionData = {
+          judgement: sectionYMap.get('judgement') ?? null,
+          judgementSource: sectionYMap.get('judgementSource') ?? 'auto',
+          answers: {}, // Always initialize answers for domains
+        };
+        const direction = sectionYMap.get('direction');
+        if (direction !== undefined) {
+          sectionData.direction = direction;
+        }
+
+        // Reconstruct nested answers
+        const answersNestedYMap = sectionYMap.get('answers');
+        if (answersNestedYMap instanceof Y.Map) {
+          for (const [qKey, questionYMap] of answersNestedYMap.entries()) {
+            if (questionYMap instanceof Y.Map) {
+              const commentValue = questionYMap.get('comment');
+              sectionData.answers[qKey] = {
+                answer: questionYMap.get('answer') ?? null,
+                comment: yTextToString(commentValue),
+              };
+            } else {
+              sectionData.answers[qKey] = questionYMap;
+            }
+          }
+        }
+        answers[key] = sectionData;
+      } else if (key === 'overall') {
+        // Overall section has judgement and direction but no nested answers
+        const sectionData = {
+          judgement: sectionYMap.get('judgement') ?? null,
+          judgementSource: sectionYMap.get('judgementSource') ?? 'auto',
+        };
+        const direction = sectionYMap.get('direction');
+        if (direction !== undefined) {
+          sectionData.direction = direction;
+        }
+        answers[key] = sectionData;
+      } else if (key === 'sectionB') {
+        const sectionData = {};
+        for (const [subKey, subValue] of sectionYMap.entries()) {
+          if (subValue instanceof Y.Map) {
+            const commentValue = subValue.get('comment');
+            sectionData[subKey] = {
+              answer: subValue.get('answer') ?? null,
+              comment: yTextToString(commentValue),
+            };
+          } else {
+            sectionData[subKey] = subValue;
+          }
+        }
+        answers[key] = sectionData;
+      } else {
+        // Other sections (planning, sectionA, sectionC, sectionD): convert Y.Map to plain object
+        // Convert Y.Text fields to strings
+        const sectionData = {};
+        for (const [fieldKey, fieldValue] of sectionYMap.entries()) {
+          if (fieldValue instanceof Y.Text) {
+            sectionData[fieldKey] = fieldValue.toString();
+          } else {
+            sectionData[fieldKey] = fieldValue;
+          }
+        }
+        answers[key] = sectionData;
+      }
+    }
+    return answers;
+  }
+
+  /**
+   * Set a Y.Text field value, preserving the Y.Text object if it exists
+   * @param {Y.Map} questionYMap - The question Y.Map
+   * @param {string} fieldKey - The field key (e.g., 'comment')
+   * @param {string|null} value - The string value to set (null becomes empty string)
+   */
+  setYTextField(questionYMap, fieldKey, value) {
+    const commentStr = value ?? '';
+    const existing = questionYMap.get(fieldKey);
+    if (existing instanceof Y.Text) {
+      // Replace contents of existing Y.Text to preserve object identity
+      existing.delete(0, existing.length);
+      existing.insert(0, commentStr);
+    } else {
+      // Create new Y.Text if it doesn't exist or was overwritten with a string
+      const newText = new Y.Text();
+      newText.insert(0, commentStr);
+      questionYMap.set(fieldKey, newText);
+    }
+  }
+
+  /**
+   * Update a single answer/section in ROBINS-I checklist
+   * @param {Y.Map} answersMap - The answers Y.Map
+   * @param {string} key - The section key (e.g., 'domain1a', 'sectionB')
+   * @param {Object} data - The answer data
+   */
+  updateAnswer(answersMap, key, data) {
+    let sectionYMap = answersMap.get(key);
+
+    // Create section Y.Map if it doesn't exist
+    if (!sectionYMap || !(sectionYMap instanceof Y.Map)) {
+      sectionYMap = new Y.Map();
+      answersMap.set(key, sectionYMap);
+    }
+
+    // Domain keys have nested 'answers' object with individual questions
+    if (key.startsWith('domain') || key === 'overall') {
+      // Update judgement and direction at section level
+      if (data.judgement !== undefined) {
+        sectionYMap.set('judgement', data.judgement);
+      }
+      if (data.judgementSource !== undefined) {
+        sectionYMap.set('judgementSource', data.judgementSource);
+      }
+      if (data.direction !== undefined) {
+        sectionYMap.set('direction', data.direction);
+      }
+
+      // Update individual questions in answers
+      if (data.answers) {
+        let answersNestedYMap = sectionYMap.get('answers');
+        if (!answersNestedYMap || !(answersNestedYMap instanceof Y.Map)) {
+          answersNestedYMap = new Y.Map();
+          sectionYMap.set('answers', answersNestedYMap);
+        }
+
+        Object.entries(data.answers).forEach(([qKey, qValue]) => {
+          let questionYMap = answersNestedYMap.get(qKey);
+          if (!questionYMap || !(questionYMap instanceof Y.Map)) {
+            questionYMap = new Y.Map();
+            answersNestedYMap.set(qKey, questionYMap);
+          }
+          if (qValue.answer !== undefined) questionYMap.set('answer', qValue.answer);
+          if (qValue.comment !== undefined)
+            this.setYTextField(questionYMap, 'comment', qValue.comment);
+        });
+      }
+    } else if (key === 'sectionB') {
+      // Section B: update individual questions or stopAssessment
+      Object.entries(data).forEach(([subKey, subValue]) => {
+        if (typeof subValue === 'object' && subValue !== null) {
+          let questionYMap = sectionYMap.get(subKey);
+          if (!questionYMap || !(questionYMap instanceof Y.Map)) {
+            questionYMap = new Y.Map();
+            sectionYMap.set(subKey, questionYMap);
+          }
+          if (subValue.answer !== undefined) questionYMap.set('answer', subValue.answer);
+          if (subValue.comment !== undefined)
+            this.setYTextField(questionYMap, 'comment', subValue.comment);
+        } else {
+          sectionYMap.set(subKey, subValue);
+        }
+      });
+    } else if (key === 'confoundingEvaluation') {
+      // Confounding evaluation: update arrays
+      if (data.predefined !== undefined) sectionYMap.set('predefined', data.predefined);
+      if (data.additional !== undefined) sectionYMap.set('additional', data.additional);
+    } else if (key === 'sectionD') {
+      // Section D: update sources or otherSpecify
+      if (data.sources !== undefined) sectionYMap.set('sources', data.sources);
+      if (data.otherSpecify !== undefined) sectionYMap.set('otherSpecify', data.otherSpecify);
+    } else {
+      // Other sections: update individual fields
+      Object.entries(data).forEach(([fieldKey, fieldValue]) => {
+        sectionYMap.set(fieldKey, fieldValue);
+      });
+    }
+  }
+
+  /**
+   * Get type-specific text getter function for ROBINS-I
+   * @param {Function} getYDoc - Function that returns the Y.Doc
+   * @returns {Function} getRobinsText function
+   */
+  getTextGetter(getYDoc) {
+    return (studyId, checklistId, sectionKey, fieldKey, questionKey = null) => {
+      const ydoc = getYDoc();
+      if (!ydoc) return null;
+
+      const studiesMap = ydoc.getMap('reviews');
+      const studyYMap = studiesMap.get(studyId);
+      if (!studyYMap) return null;
+
+      const checklistsMap = studyYMap.get('checklists');
+      if (!checklistsMap) return null;
+
+      const checklistYMap = checklistsMap.get(checklistId);
+      if (!checklistYMap) return null;
+
+      const checklistType = checklistYMap.get('type');
+      if (checklistType !== 'ROBINS_I') return null;
+
+      const answersMap = checklistYMap.get('answers');
+      if (!answersMap) return null;
+
+      const sectionYMap = answersMap.get(sectionKey);
+      if (!sectionYMap || !(sectionYMap instanceof Y.Map)) return null;
+
+      // Handle domain questions (domain1a, domain1b, etc.)
+      if (sectionKey.startsWith('domain') && questionKey) {
+        const answersNestedYMap = sectionYMap.get('answers');
+        if (!answersNestedYMap || !(answersNestedYMap instanceof Y.Map)) return null;
+
+        const questionYMap = answersNestedYMap.get(questionKey);
+        if (!questionYMap || !(questionYMap instanceof Y.Map)) return null;
+
+        const text = questionYMap.get(fieldKey);
+        if (text instanceof Y.Text) {
+          return text;
+        }
+
+        // Create Y.Text if it doesn't exist
+        const newText = new Y.Text();
+        questionYMap.set(fieldKey, newText);
+        return newText;
+      }
+
+      // Handle sectionB questions (b1, b2, b3)
+      if (sectionKey === 'sectionB' && questionKey) {
+        const questionYMap = sectionYMap.get(questionKey);
+        if (!questionYMap || !(questionYMap instanceof Y.Map)) return null;
+
+        const text = questionYMap.get(fieldKey);
+        if (text instanceof Y.Text) {
+          return text;
+        }
+
+        // Create Y.Text if it doesn't exist
+        const newText = new Y.Text();
+        questionYMap.set(fieldKey, newText);
+        return newText;
+      }
+
+      // Handle section-level fields (planning, sectionA, sectionC, sectionD)
+      const text = sectionYMap.get(fieldKey);
+      if (text instanceof Y.Text) {
+        return text;
+      }
+
+      // Create Y.Text if it doesn't exist
+      const newText = new Y.Text();
+      sectionYMap.set(fieldKey, newText);
+      return newText;
+    };
+  }
+}
diff --git a/packages/web/src/primitives/useProject/checklists/handlers/robins-i.test.js b/packages/web/src/primitives/useProject/checklists/handlers/robins-i.test.js
new file mode 100644
index 000000000..025c8f125
--- /dev/null
+++ b/packages/web/src/primitives/useProject/checklists/handlers/robins-i.test.js
@@ -0,0 +1,66 @@
+/**
+ * Tests for ROBINSIHandler - comment field Y.Text preservation
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as Y from 'yjs';
+import { ROBINSIHandler } from './robins-i.js';
+
+describe('ROBINSIHandler - comment field Y.Text handling', () => {
+  let handler;
+  let doc;
+
+  beforeEach(() => {
+    handler = new ROBINSIHandler();
+    doc = new Y.Doc();
+  });
+
+  describe('setYTextField helper method', () => {
+    it('should create Y.Text when field does not exist', () => {
+      const questionYMap = doc.getMap('question');
+      handler.setYTextField(questionYMap, 'comment', 'New comment');
+
+      const comment = questionYMap.get('comment');
+      expect(comment).toBeInstanceOf(Y.Text);
+      expect(comment.toString()).toBe('New comment');
+    });
+
+    it('should update existing Y.Text in place, preserving object identity', () => {
+      const questionYMap = doc.getMap('question');
+      const existingText = new Y.Text();
+      existingText.insert(0, 'Original comment');
+      questionYMap.set('comment', existingText);
+
+      handler.setYTextField(questionYMap, 'comment', 'Updated comment');
+
+      const comment = questionYMap.get('comment');
+      expect(comment).toBe(existingText);
+      expect(comment.toString()).toBe('Updated comment');
+    });
+
+    it('should upgrade legacy string to Y.Text', () => {
+      const questionYMap = doc.getMap('question');
+      questionYMap.set('comment', 'Legacy string comment');
+
+      handler.setYTextField(questionYMap, 'comment', 'New comment');
+
+      const comment = questionYMap.get('comment');
+      expect(comment).toBeInstanceOf(Y.Text);
+      expect(comment.toString()).toBe('New comment');
+    });
+
+    it('should handle null by converting to empty string', () => {
+      const questionYMap = doc.getMap('question');
+      const existingText = new Y.Text();
+      existingText.insert(0, 'Existing text');
+      questionYMap.set('comment', existingText);
+
+      handler.setYTextField(questionYMap, 'comment', null);
+
+      const comment = questionYMap.get('comment');
+      expect(comment).toBeInstanceOf(Y.Text);
+      expect(comment.toString()).toBe('');
+      expect(comment).toBe(existingText);
+    });
+  });
+});
diff --git a/packages/web/src/primitives/useProject/checklists/index.js b/packages/web/src/primitives/useProject/checklists/index.js
new file mode 100644
index 000000000..c01b8a28d
--- /dev/null
+++ b/packages/web/src/primitives/useProject/checklists/index.js
@@ -0,0 +1,234 @@
+/**
+ * Checklist operations for useProject
+ * Main coordinator that delegates to type-specific handlers
+ */
+
+import * as Y from 'yjs';
+import { createChecklistOfType, CHECKLIST_TYPES } from '@/checklist-registry';
+import { CHECKLIST_STATUS } from '@/constants/checklist-status.js';
+import { createCommonOperations } from './common.js';
+import { AMSTAR2Handler } from './handlers/amstar2.js';
+import { ROBINSIHandler } from './handlers/robins-i.js';
+
+/**
+ * Creates checklist operations
+ * @param {string} projectId - The project ID
+ * @param {Function} getYDoc - Function that returns the Y.Doc
+ * @param {Function} isSynced - Function that returns sync status
+ * @returns {Object} Checklist operations
+ */
+export function createChecklistOperations(_projectId, getYDoc, _isSynced) {
+  // Initialize common operations
+  const commonOps = createCommonOperations(getYDoc);
+
+  // Initialize type-specific handlers
+  const amstar2Handler = new AMSTAR2Handler();
+  const robinsIHandler = new ROBINSIHandler();
+
+  // Handler registry
+  const handlers = {
+    [CHECKLIST_TYPES.AMSTAR2]: amstar2Handler,
+    [CHECKLIST_TYPES.ROBINS_I]: robinsIHandler,
+  };
+
+  /**
+   * Get handler for a checklist type
+   * @param {string} type - The checklist type
+   * @returns {ChecklistHandler|null} The handler or null
+   */
+  function getHandler(type) {
+    return handlers[type] || null;
+  }
+
+  /**
+   * Create a checklist in a study
+   * @param {string} studyId - The study ID
+   * @param {string} type - Checklist type (default: 'AMSTAR2')
+   * @param {string|null} assignedTo - User ID to assign to
+   * @returns {string|null} The checklist ID or null if failed
+   */
+  function createChecklist(studyId, type = 'AMSTAR2', assignedTo = null) {
+    const ydoc = getYDoc();
+    if (!ydoc) return null;
+
+    const studiesMap = ydoc.getMap('reviews');
+    const studyYMap = studiesMap.get(studyId);
+
+    if (!studyYMap) return null;
+
+    let checklistsMap = studyYMap.get('checklists');
+    if (!checklistsMap) {
+      checklistsMap = new Y.Map();
+      studyYMap.set('checklists', checklistsMap);
+    }
+
+    const checklistId = crypto.randomUUID();
+    const now = Date.now();
+
+    // Get the default answers structure for this checklist type using the registry
+    const checklistTemplate = createChecklistOfType(type, {
+      id: checklistId,
+      name: `${type} Checklist`,
+      createdAt: now,
+    });
+
+    // Get handler for this type
+    const handler = getHandler(type);
+    if (!handler) {
+      // Fallback for unknown types: store data directly
+      const checklistYMap = new Y.Map();
+      checklistYMap.set('type', type);
+      checklistYMap.set('title', `${type} Checklist`);
+      checklistYMap.set('assignedTo', assignedTo);
+      checklistYMap.set('status', CHECKLIST_STATUS.PENDING);
+      checklistYMap.set('createdAt', now);
+      checklistYMap.set('updatedAt', now);
+
+      const answersYMap = new Y.Map();
+      Object.entries(checklistTemplate).forEach(([key, value]) => {
+        answersYMap.set(key, value);
+      });
+      checklistYMap.set('answers', answersYMap);
+      checklistsMap.set(checklistId, checklistYMap);
+      studyYMap.set('updatedAt', now);
+      return checklistId;
+    }
+
+    // Extract answers using handler
+    const answersData = handler.extractAnswersFromTemplate(checklistTemplate);
+
+    // Create checklist Y.Map
+    const checklistYMap = new Y.Map();
+    checklistYMap.set('type', type);
+    checklistYMap.set('title', `${type} Checklist`);
+    checklistYMap.set('assignedTo', assignedTo);
+    checklistYMap.set('status', CHECKLIST_STATUS.PENDING);
+    checklistYMap.set('createdAt', now);
+    checklistYMap.set('updatedAt', now);
+
+    // Create answers Y.Map using handler
+    const answersYMap = handler.createAnswersYMap(answersData);
+    checklistYMap.set('answers', answersYMap);
+
+    checklistsMap.set(checklistId, checklistYMap);
+
+    // Update study's updatedAt
+    studyYMap.set('updatedAt', now);
+
+    return checklistId;
+  }
+
+  /**
+   * Get full checklist data including answers in plain object format
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   * @returns {Object|null} The checklist data or null
+   */
+  function getChecklistData(studyId, checklistId) {
+    const result = commonOps.getChecklistYMap(studyId, checklistId);
+    if (!result) return null;
+
+    const { checklistYMap, checklistType } = result;
+    const data = checklistYMap.toJSON ? checklistYMap.toJSON() : {};
+
+    // Get handler for this type
+    const handler = getHandler(checklistType);
+    const answersMap = checklistYMap.get('answers');
+
+    let answers = {};
+    if (answersMap && typeof answersMap.entries === 'function') {
+      if (handler) {
+        // Use handler to serialize
+        answers = handler.serializeAnswers(answersMap);
+      } else {
+        // Fallback for unknown types: simple toJSON
+        for (const [key, sectionYMap] of answersMap.entries()) {
+          const sectionData = sectionYMap.toJSON ? sectionYMap.toJSON() : sectionYMap;
+          answers[key] = sectionData;
+        }
+      }
+    }
+
+    return {
+      ...data,
+      answers,
+    };
+  }
+
+  /**
+   * Update a single answer/section in a checklist
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   * @param {string} key - The answer key (e.g., 'q1' for AMSTAR2, 'domain1a' for ROBINS-I)
+   * @param {Object} data - The answer data (structure depends on checklist type)
+   */
+  function updateChecklistAnswer(studyId, checklistId, key, data) {
+    const result = commonOps.getChecklistYMap(studyId, checklistId);
+    if (!result) return;
+
+    const { checklistYMap, checklistType } = result;
+
+    let answersMap = checklistYMap.get('answers');
+    if (!answersMap) {
+      answersMap = new Y.Map();
+      checklistYMap.set('answers', answersMap);
+    }
+
+    // Get handler for this type
+    const handler = getHandler(checklistType);
+    if (handler) {
+      // Use handler to update
+      handler.updateAnswer(answersMap, key, data);
+    } else {
+      // Fallback for unknown types: store data directly
+      answersMap.set(key, data);
+    }
+
+    // Auto-transition status from 'pending' to 'in-progress' on first edit
+    const currentStatus = checklistYMap.get('status');
+    if (currentStatus === CHECKLIST_STATUS.PENDING) {
+      checklistYMap.set('status', CHECKLIST_STATUS.IN_PROGRESS);
+    }
+
+    checklistYMap.set('updatedAt', Date.now());
+  }
+
+  /**
+   * Get a Y.Text reference for a question's note (AMSTAR2-specific)
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   * @param {string} questionKey - The question key (e.g., 'q1', 'q9' for multi-part)
+   * @returns {Y.Text|null} The Y.Text reference or null
+   */
+  function getQuestionNote(studyId, checklistId, questionKey) {
+    const textGetter = amstar2Handler.getTextGetter(getYDoc);
+    if (!textGetter) return null;
+    return textGetter(studyId, checklistId, questionKey);
+  }
+
+  /**
+   * Get a Y.Text reference for a ROBINS-I free-text field
+   * @param {string} studyId - The study ID
+   * @param {string} checklistId - The checklist ID
+   * @param {string} sectionKey - The section key
+   * @param {string} fieldKey - The field key
+   * @param {string} [questionKey] - Optional question key
+   * @returns {Y.Text|null} The Y.Text reference or null
+   */
+  function getRobinsText(studyId, checklistId, sectionKey, fieldKey, questionKey = null) {
+    const textGetter = robinsIHandler.getTextGetter(getYDoc);
+    if (!textGetter) return null;
+    return textGetter(studyId, checklistId, sectionKey, fieldKey, questionKey);
+  }
+
+  return {
+    createChecklist,
+    updateChecklist: commonOps.updateChecklist,
+    deleteChecklist: commonOps.deleteChecklist,
+    getChecklistAnswersMap: commonOps.getChecklistAnswersMap,
+    getChecklistData,
+    updateChecklistAnswer,
+    getQuestionNote,
+    getRobinsText,
+  };
+}
diff --git a/packages/web/src/primitives/useProject/index.js b/packages/web/src/primitives/useProject/index.js
index e97b70dfd..1b29b17fe 100644
--- a/packages/web/src/primitives/useProject/index.js
+++ b/packages/web/src/primitives/useProject/index.js
@@ -15,7 +15,7 @@ import useOnlineStatus from '../useOnlineStatus.js';
 import { createConnectionManager } from './connection.js';
 import { createSyncManager } from './sync.js';
 import { createStudyOperations } from './studies.js';
-import { createChecklistOperations } from './checklists.js';
+import { createChecklistOperations } from './checklists/index.js';
 import { createPdfOperations } from './pdfs.js';
 import { createReconciliationOperations } from './reconciliation.js';
 
@@ -212,6 +212,7 @@ export function useProject(projectId) {
       getChecklistData: connectionEntry.checklistOps.getChecklistData,
       updateChecklistAnswer: connectionEntry.checklistOps.updateChecklistAnswer,
       getQuestionNote: connectionEntry.checklistOps.getQuestionNote,
+      getRobinsText: connectionEntry.checklistOps.getRobinsText,
       // PDF operations
       addPdfToStudy: connectionEntry.pdfOps.addPdfToStudy,
       removePdfFromStudy: connectionEntry.pdfOps.removePdfFromStudy,
@@ -335,6 +336,7 @@ export function useProject(projectId) {
     updateChecklistAnswer: (...args) =>
       connectionEntry?.checklistOps?.updateChecklistAnswer(...args),
     getQuestionNote: (...args) => connectionEntry?.checklistOps?.getQuestionNote(...args),
+    getRobinsText: (...args) => connectionEntry?.checklistOps?.getRobinsText(...args),
 
     // PDF operations
     addPdfToStudy: (...args) => connectionEntry?.pdfOps?.addPdfToStudy(...args),
diff --git a/packages/web/src/primitives/useProject/sync.js b/packages/web/src/primitives/useProject/sync.js
index bcd0ae366..d5ebc87f1 100644
--- a/packages/web/src/primitives/useProject/sync.js
+++ b/packages/web/src/primitives/useProject/sync.js
@@ -3,6 +3,7 @@
  * Handles syncing Y.Doc state to the project store
  */
 
+import * as Y from 'yjs';
 import projectStore from '@/stores/projectStore.js';
 import { scoreChecklistOfType } from '@/checklist-registry/index.js';
 import { getAnswers as getAMSTAR2Answers } from '@/components/checklist/AMSTAR2Checklist/checklist.js';
@@ -223,9 +224,11 @@ function extractAnswersFromYMap(answersMap, checklistType) {
         if (answersNestedYMap && typeof answersNestedYMap.entries === 'function') {
           for (const [qKey, questionYMap] of answersNestedYMap.entries()) {
             if (questionYMap && typeof questionYMap.get === 'function') {
+              const commentValue = questionYMap.get('comment');
               sectionData.answers[qKey] = {
                 answer: questionYMap.get('answer') ?? null,
-                comment: questionYMap.get('comment') ?? '',
+                comment:
+                  commentValue instanceof Y.Text ? commentValue.toString() : (commentValue ?? ''),
               };
             } else {
               sectionData.answers[qKey] = questionYMap;
@@ -246,9 +249,11 @@ function extractAnswersFromYMap(answersMap, checklistType) {
         const sectionData = {};
         for (const [subKey, subValue] of sectionYMap.entries()) {
           if (subValue && typeof subValue.get === 'function') {
+            const commentValue = subValue.get('comment');
             sectionData[subKey] = {
               answer: subValue.get('answer') ?? null,
-              comment: subValue.get('comment') ?? '',
+              comment:
+                commentValue instanceof Y.Text ? commentValue.toString() : (commentValue ?? ''),
             };
           } else {
             sectionData[subKey] = subValue;
@@ -256,7 +261,16 @@ function extractAnswersFromYMap(answersMap, checklistType) {
         }
         answers[key] = sectionData;
       } else {
-        answers[key] = sectionYMap.toJSON ? sectionYMap.toJSON() : sectionYMap;
+        // Other sections (planning, sectionA, sectionC, sectionD): convert Y.Text to strings
+        const sectionData = {};
+        for (const [fieldKey, fieldValue] of sectionYMap.entries()) {
+          if (fieldValue instanceof Y.Text) {
+            sectionData[fieldKey] = fieldValue.toString();
+          } else {
+            sectionData[fieldKey] = fieldValue;
+          }
+        }
+        answers[key] = sectionData;
       }
     } else {
       // AMSTAR2 and other types: simple toJSON conversion
diff --git a/packages/workers/migrations/meta/0000_snapshot.json b/packages/workers/migrations/meta/0000_snapshot.json
index 738a907e6..41c3935c8 100644
--- a/packages/workers/migrations/meta/0000_snapshot.json
+++ b/packages/workers/migrations/meta/0000_snapshot.json
@@ -107,12 +107,8 @@
           "name": "account_userId_user_id_fk",
           "tableFrom": "account",
           "tableTo": "user",
-          "columnsFrom": [
-            "userId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -190,12 +186,8 @@
           "name": "invitation_inviterId_user_id_fk",
           "tableFrom": "invitation",
           "tableTo": "user",
-          "columnsFrom": [
-            "inviterId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["inviterId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -203,12 +195,8 @@
           "name": "invitation_organizationId_organization_id_fk",
           "tableFrom": "invitation",
           "tableTo": "organization",
-          "columnsFrom": [
-            "organizationId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["organizationId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -284,12 +272,8 @@
           "name": "mediaFiles_uploadedBy_user_id_fk",
           "tableFrom": "mediaFiles",
           "tableTo": "user",
-          "columnsFrom": [
-            "uploadedBy"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["uploadedBy"],
+          "columnsTo": ["id"],
           "onDelete": "set null",
           "onUpdate": "no action"
         }
@@ -345,12 +329,8 @@
           "name": "member_userId_user_id_fk",
           "tableFrom": "member",
           "tableTo": "user",
-          "columnsFrom": [
-            "userId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -358,12 +338,8 @@
           "name": "member_organizationId_organization_id_fk",
           "tableFrom": "member",
           "tableTo": "organization",
-          "columnsFrom": [
-            "organizationId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["organizationId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -422,9 +398,7 @@
       "indexes": {
         "organization_slug_unique": {
           "name": "organization_slug_unique",
-          "columns": [
-            "slug"
-          ],
+          "columns": ["slug"],
           "isUnique": true
         }
       },
@@ -528,9 +502,7 @@
       "indexes": {
         "project_invitations_token_unique": {
           "name": "project_invitations_token_unique",
-          "columns": [
-            "token"
-          ],
+          "columns": ["token"],
           "isUnique": true
         }
       },
@@ -539,12 +511,8 @@
           "name": "project_invitations_orgId_organization_id_fk",
           "tableFrom": "project_invitations",
           "tableTo": "organization",
-          "columnsFrom": [
-            "orgId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["orgId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -552,12 +520,8 @@
           "name": "project_invitations_projectId_projects_id_fk",
           "tableFrom": "project_invitations",
           "tableTo": "projects",
-          "columnsFrom": [
-            "projectId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["projectId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -565,12 +529,8 @@
           "name": "project_invitations_invitedBy_user_id_fk",
           "tableFrom": "project_invitations",
           "tableTo": "user",
-          "columnsFrom": [
-            "invitedBy"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["invitedBy"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -626,12 +586,8 @@
           "name": "project_members_projectId_projects_id_fk",
           "tableFrom": "project_members",
           "tableTo": "projects",
-          "columnsFrom": [
-            "projectId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["projectId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -639,12 +595,8 @@
           "name": "project_members_userId_user_id_fk",
           "tableFrom": "project_members",
           "tableTo": "user",
-          "columnsFrom": [
-            "userId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -714,12 +666,8 @@
           "name": "projects_orgId_organization_id_fk",
           "tableFrom": "projects",
           "tableTo": "organization",
-          "columnsFrom": [
-            "orgId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["orgId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -727,12 +675,8 @@
           "name": "projects_createdBy_user_id_fk",
           "tableFrom": "projects",
           "tableTo": "user",
-          "columnsFrom": [
-            "createdBy"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["createdBy"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -820,9 +764,7 @@
       "indexes": {
         "session_token_unique": {
           "name": "session_token_unique",
-          "columns": [
-            "token"
-          ],
+          "columns": ["token"],
           "isUnique": true
         }
       },
@@ -831,12 +773,8 @@
           "name": "session_userId_user_id_fk",
           "tableFrom": "session",
           "tableTo": "user",
-          "columnsFrom": [
-            "userId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         },
@@ -844,12 +782,8 @@
           "name": "session_impersonatedBy_user_id_fk",
           "tableFrom": "session",
           "tableTo": "user",
-          "columnsFrom": [
-            "impersonatedBy"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["impersonatedBy"],
+          "columnsTo": ["id"],
           "onDelete": "set null",
           "onUpdate": "no action"
         },
@@ -857,12 +791,8 @@
           "name": "session_activeOrganizationId_organization_id_fk",
           "tableFrom": "session",
           "tableTo": "organization",
-          "columnsFrom": [
-            "activeOrganizationId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["activeOrganizationId"],
+          "columnsTo": ["id"],
           "onDelete": "set null",
           "onUpdate": "no action"
         }
@@ -960,23 +890,17 @@
       "indexes": {
         "subscriptions_userId_unique": {
           "name": "subscriptions_userId_unique",
-          "columns": [
-            "userId"
-          ],
+          "columns": ["userId"],
           "isUnique": true
         },
         "subscriptions_stripeCustomerId_unique": {
           "name": "subscriptions_stripeCustomerId_unique",
-          "columns": [
-            "stripeCustomerId"
-          ],
+          "columns": ["stripeCustomerId"],
           "isUnique": true
         },
         "subscriptions_stripeSubscriptionId_unique": {
           "name": "subscriptions_stripeSubscriptionId_unique",
-          "columns": [
-            "stripeSubscriptionId"
-          ],
+          "columns": ["stripeSubscriptionId"],
           "isUnique": true
         }
       },
@@ -985,12 +909,8 @@
           "name": "subscriptions_userId_user_id_fk",
           "tableFrom": "subscriptions",
           "tableTo": "user",
-          "columnsFrom": [
-            "userId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -1053,12 +973,8 @@
           "name": "twoFactor_userId_user_id_fk",
           "tableFrom": "twoFactor",
           "tableTo": "user",
-          "columnsFrom": [
-            "userId"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["userId"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -1198,16 +1114,12 @@
       "indexes": {
         "user_email_unique": {
           "name": "user_email_unique",
-          "columns": [
-            "email"
-          ],
+          "columns": ["email"],
           "isUnique": true
         },
         "user_username_unique": {
           "name": "user_username_unique",
-          "columns": [
-            "username"
-          ],
+          "columns": ["username"],
           "isUnique": true
         }
       },
@@ -1281,4 +1193,4 @@
   "internal": {
     "indexes": {}
   }
-}
\ No newline at end of file
+}
diff --git a/packages/workers/migrations/meta/_journal.json b/packages/workers/migrations/meta/_journal.json
index 957112561..abac566a1 100644
--- a/packages/workers/migrations/meta/_journal.json
+++ b/packages/workers/migrations/meta/_journal.json
@@ -10,4 +10,4 @@
       "breakpoints": true
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/packages/workers/scripts/generate-openapi.mjs b/packages/workers/scripts/generate-openapi.mjs
index 4511a4606..dc35b84d8 100644
--- a/packages/workers/scripts/generate-openapi.mjs
+++ b/packages/workers/scripts/generate-openapi.mjs
@@ -252,9 +252,18 @@ async function generate() {
     // Organization routes (new org-scoped architecture)
     { file: 'src/routes/orgs/index.js', basePath: '/api/orgs' },
     { file: 'src/routes/orgs/projects.js', basePath: '/api/orgs/{orgId}/projects' },
-    { file: 'src/routes/orgs/members.js', basePath: '/api/orgs/{orgId}/projects/{projectId}/members' },
-    { file: 'src/routes/orgs/invitations.js', basePath: '/api/orgs/{orgId}/projects/{projectId}/invitations' },
-    { file: 'src/routes/orgs/pdfs.js', basePath: '/api/orgs/{orgId}/projects/{projectId}/studies/{studyId}/pdfs' },
+    {
+      file: 'src/routes/orgs/members.js',
+      basePath: '/api/orgs/{orgId}/projects/{projectId}/members',
+    },
+    {
+      file: 'src/routes/orgs/invitations.js',
+      basePath: '/api/orgs/{orgId}/projects/{projectId}/invitations',
+    },
+    {
+      file: 'src/routes/orgs/pdfs.js',
+      basePath: '/api/orgs/{orgId}/projects/{projectId}/studies/{studyId}/pdfs',
+    },
     // Legacy routes (deprecated, kept for backward compatibility detection)
     { file: 'src/routes/projects.js', basePath: '/api/projects' },
     { file: 'src/routes/members.js', basePath: '/api/projects/{projectId}/members' },
diff --git a/scripts/loc-report.mjs b/scripts/loc-report.mjs
index 83ec1f99d..f4f878907 100644
--- a/scripts/loc-report.mjs
+++ b/scripts/loc-report.mjs
@@ -20,6 +20,7 @@ import { dirname } from 'path';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(__dirname, '..');
+// const ROOT = '/Users/jacobmaynard/Documents/Repos/Courses/DOSSP/';
 
 function checkCommand(command) {
   const result = spawnSync('which', [command], { encoding: 'utf8' });