feat(exam): add mark scheme editor

2026-06-07 00:34:56 +01:00
7 changed files with 687 additions and 362 deletions
@@ -31,7 +31,10 @@ vi.mock('./pages/NotFoundPublic', () => ({ default: () => <div>Public Not Found<
 vi.mock('./pages/tldraw/TLDrawCanvas', () => ({ default: () => <div>Public Home</div> }));
 vi.mock('./pages/tldraw/singlePlayerPage', () => ({ default: () => <div>Single Player</div> }));
 vi.mock('./pages/tldraw/multiplayerUser', () => ({ default: () => <div>Multiplayer</div> }));
-vi.mock('./pages/exam', () => ({ ExamDashboardPage: () => <div>Exam Marker</div> }));
+vi.mock('./pages/exam', () => ({
+  ExamDashboardPage: () => <div>Exam Marker</div>,
+  MarkSchemePage: () => <div>Mark Scheme editor</div>,
+}));
 vi.mock('./pages/user/calendarPage', () => ({ default: () => <div>Calendar</div> }));
 vi.mock('./pages/user/settingsPage', () => ({ default: () => <div>Settings</div> }));
 vi.mock('./pages/tldraw/devPlayerPage', () => ({ default: () => <div>TLDraw Dev</div> }));
@@ -122,3 +125,22 @@ describe('/admin route authorization', () => {
    expect(screen.getByText('Platform Admin Page')).toBeInTheDocument();
  });
 });
+
+
+describe('exam-marker routes', () => {
+  beforeEach(() => {
+    mockUseAuth.mockReset();
+  });
+
+  it('renders the mark scheme editor route for authenticated users', () => {
+    mockUseAuth.mockReturnValue(authState({
+      user: { id: 'teacher-1', email: '[email protected]', user_type: 'email_teacher' },
+      user_role: 'email_teacher',
+      accessToken: 'token',
+    }));
+
+    renderAt('/exam-marker/template-123/marks');
+
+    expect(screen.getByText('Mark Scheme editor')).toBeInTheDocument();
+  });
+});
@@ -7,7 +7,7 @@ import LoginPage from './pages/auth/loginPage';
 import SignupPage from './pages/auth/signupPage';
 import SinglePlayerPage from './pages/tldraw/singlePlayerPage';
 import MultiplayerUser from './pages/tldraw/multiplayerUser';
-import { ExamDashboardPage } from './pages/exam';
+import { ExamDashboardPage, MarkSchemePage } from './pages/exam';
 import { ErrorBoundary } from './components/ErrorBoundary';
 import CalendarPage from './pages/user/calendarPage';
 import SettingsPage from './pages/user/settingsPage';
@@ -183,6 +183,7 @@ const AppRoutes: React.FC = () => {
            <Route path="/search" element={<SearxngPage />} />
            <Route path="/teacher-planner" element={<TeacherPlanner />} />
            <Route path="/exam-marker" element={<ErrorBoundary><ExamDashboardPage /></ErrorBoundary>} />
+            <Route path="/exam-marker/:templateId/marks" element={<ErrorBoundary><MarkSchemePage /></ErrorBoundary>} />
            <Route path="/doc-intelligence/:fileId" element={<CCDocumentIntelligence />} />
            <Route path="/morphic" element={<MorphicPage />} />
            <Route path="/tldraw-dev" element={<TLDrawDevPage />} />
@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
 import { useNavigate } from 'react-router-dom';
 import {
  Alert,
@@ -22,8 +22,7 @@ import {
 import AddIcon from '@mui/icons-material/Add';
 import ArchiveIcon from '@mui/icons-material/Archive';
 import AssignmentIcon from '@mui/icons-material/Assignment';
-import ContentCopyIcon from '@mui/icons-material/ContentCopy';
-import EditIcon from '@mui/icons-material/Edit';
+import GradingIcon from '@mui/icons-material/Grading';

 import { useAuth } from '../../contexts/AuthContext';
 import { examRepository } from '../../services/exam/examRepository';
@@ -36,51 +35,6 @@ const STATUS_COLOR: Record<string, 'default' | 'info' | 'success' | 'warning'> =
  archived: 'default',
 };

-const VERSION_SEPARATOR = ' · ';
-const VERSION_RE = /(?:^|\s)[vV](\d+(?:\.\d+)*)$/;
-
-type DialogMode = 'create' | 'edit' | 'duplicate';
-
-type TemplateDialogState = {
-  mode: DialogMode;
-  template?: ExamTemplate;
-} | null;
-
-function splitTemplateTitle(title: string): { name: string; version: string } {
-  const parts = title.split(VERSION_SEPARATOR);
-  const possibleVersion = parts[parts.length - 1]?.trim() ?? '';
-  if (parts.length > 1 && VERSION_RE.test(possibleVersion)) {
-    return { name: parts.slice(0, -1).join(VERSION_SEPARATOR).trim(), version: possibleVersion };
-  }
-  return { name: title, version: 'v1' };
-}
-
-function composeTemplateTitle(name: string, version: string): string {
-  const cleanName = name.trim();
-  const cleanVersion = version.trim();
-  return cleanVersion ? `${cleanName}${VERSION_SEPARATOR}${cleanVersion}` : cleanName;
-}
-
-function nextVersionLabel(version: string): string {
-  const match = version.trim().match(VERSION_RE);
-  if (!match) return 'v2';
-  const segments = match[1].split('.');
-  const last = Number(segments[segments.length - 1]);
-  segments[segments.length - 1] = Number.isFinite(last) ? String(last + 1) : '2';
-  return `v${segments.join('.')}`;
-}
-
-function paperKey(t: ExamTemplate): string {
-  return t.exam_id ?? t.source_file_id ?? t.exam_code ?? t.subject ?? 'custom-paper';
-}
-
-function paperLabel(t: ExamTemplate): string {
-  if (t.exam_code) return t.exam_code;
-  if (t.subject) return t.subject;
-  if (t.source_file_id) return 'Uploaded paper';
-  return 'Custom paper';
-}
-
 const ExamDashboardPage: React.FC = () => {
  const navigate = useNavigate();
  const { bootstrapData } = useAuth();
@@ -90,9 +44,8 @@ const ExamDashboardPage: React.FC = () => {
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

-  const [dialog, setDialog] = useState<TemplateDialogState>(null);
-  const [templateName, setTemplateName] = useState('');
-  const [version, setVersion] = useState('v1');
+  const [createOpen, setCreateOpen] = useState(false);
+  const [title, setTitle] = useState('');
  const [subject, setSubject] = useState('');
  const [saving, setSaving] = useState(false);

@@ -114,99 +67,33 @@ const ExamDashboardPage: React.FC = () => {
    void load();
  }, [load, instituteId]);

-  const groupedTemplates = useMemo(() => {
-    const groups = new Map<string, { label: string; templates: ExamTemplate[] }>();
-    templates.forEach((template) => {
-      const key = paperKey(template);
-      const existing = groups.get(key);
-      if (existing) {
-        existing.templates.push(template);
-      } else {
-        groups.set(key, { label: paperLabel(template), templates: [template] });
-      }
-    });
-    return Array.from(groups.entries()).map(([key, group]) => ({ key, ...group }));
-  }, [templates]);
-
-  const openCreate = () => {
-    setTemplateName('New template');
-    setVersion('v1');
-    setSubject('');
-    setDialog({ mode: 'create' });
-  };
-
-  const openEdit = (template: ExamTemplate, ev: React.MouseEvent) => {
-    ev.stopPropagation();
-    const parsed = splitTemplateTitle(template.title);
-    setTemplateName(parsed.name);
-    setVersion(parsed.version);
-    setSubject(template.subject ?? '');
-    setDialog({ mode: 'edit', template });
-  };
-
-  const openDuplicate = (template: ExamTemplate, ev: React.MouseEvent) => {
-    ev.stopPropagation();
-    const parsed = splitTemplateTitle(template.title);
-    setTemplateName(parsed.name);
-    setVersion(nextVersionLabel(parsed.version));
-    setSubject(template.subject ?? '');
-    setDialog({ mode: 'duplicate', template });
-  };
-
-  const closeDialog = () => {
-    if (!saving) setDialog(null);
-  };
-
-  const handleSaveDialog = async () => {
-    if (!dialog || !templateName.trim()) return;
-    const title = composeTemplateTitle(templateName, version);
+  const handleCreate = async () => {
+    if (!title.trim()) return;
    setSaving(true);
    try {
-      if (dialog.mode === 'create') {
-        const created = await examRepository.createTemplate({
-          title,
-          subject: subject.trim() || undefined,
-          institute_id: instituteId,
-        });
-        setDialog(null);
-        navigate(`/exam-marker/${created.id}/setup`);
-        return;
-      }
-
-      if (!dialog.template) return;
-
-      if (dialog.mode === 'duplicate') {
-        const created = await examRepository.duplicateTemplate(dialog.template.id, title);
-        setTemplates((prev) => [created, ...prev]);
-        setDialog(null);
-        navigate(`/exam-marker/${created.id}/setup`);
-        return;
-      }
-
-      const updated = await examRepository.updateTemplateMeta(dialog.template.id, {
-        title,
-        subject: subject.trim() || null,
+      const created = await examRepository.createTemplate({
+        title: title.trim(),
+        subject: subject.trim() || undefined,
+        institute_id: instituteId,
      });
-      setTemplates((prev) => prev.map((t) => (t.id === updated.id ? updated : t)));
-      setDialog(null);
+      setCreateOpen(false);
+      setTitle('');
+      setSubject('');
+      navigate(`/exam-marker/${created.id}/setup`);
    } catch (e) {
      const msg = e instanceof Error ? e.message : String(e);
-      logger.error('cc-exam-marker', 'Template action failed', { message: msg, mode: dialog.mode });
+      logger.error('cc-exam-marker', 'Create template failed', { message: msg });
      setError(msg);
    } finally {
      setSaving(false);
    }
  };

-  const handleArchive = async (template: ExamTemplate, ev: React.MouseEvent) => {
+  const handleArchive = async (id: string, ev: React.MouseEvent) => {
    ev.stopPropagation();
-    const parsed = splitTemplateTitle(template.title);
-    if (!window.confirm(`Archive ${parsed.name} ${parsed.version}? This hides it from the dashboard but keeps the work recoverable.`)) {
-      return;
-    }
    try {
-      await examRepository.archiveTemplate(template.id);
-      setTemplates((prev) => prev.filter((t) => t.id !== template.id));
+      await examRepository.archiveTemplate(id);
+      setTemplates((prev) => prev.filter((t) => t.id !== id));
    } catch (e) {
      const msg = e instanceof Error ? e.message : String(e);
      logger.error('cc-exam-marker', 'Archive failed', { message: msg });
@@ -214,12 +101,6 @@ const ExamDashboardPage: React.FC = () => {
    }
  };

-  const dialogTitle = dialog?.mode === 'edit'
-    ? 'Rename template / edit version'
-    : dialog?.mode === 'duplicate'
-      ? 'Duplicate as new version'
-      : 'New exam template';
-
  return (
    <Container maxWidth="lg" sx={{ py: 6 }}>
      <Stack spacing={4}>
@@ -228,11 +109,11 @@ const ExamDashboardPage: React.FC = () => {
            <Typography variant="h3" component="h1" gutterBottom>
              Exam Marker
            </Typography>
-            <Typography variant="body1" color="text.secondary" sx={{ maxWidth: 620 }}>
-              Build multiple named templates for the same paper, version them as your setup changes, and archive drafts you no longer need.
+            <Typography variant="body1" color="text.secondary" sx={{ maxWidth: 560 }}>
+              Build a template for an exam paper, then run marking batches against your classes.
            </Typography>
          </Box>
-          <Button variant="contained" startIcon={<AddIcon />} onClick={openCreate}>
+          <Button variant="contained" startIcon={<AddIcon />} onClick={() => setCreateOpen(true)}>
            New template
          </Button>
        </Box>
@@ -252,118 +133,83 @@ const ExamDashboardPage: React.FC = () => {
            <AssignmentIcon sx={{ fontSize: 48, color: 'text.disabled', mb: 1 }} />
            <Typography variant="h6" gutterBottom>No exam templates yet</Typography>
            <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
-              Create your first named template to start mapping an exam paper.
+              Create your first template to start mapping an exam paper.
            </Typography>
-            <Button variant="outlined" startIcon={<AddIcon />} onClick={openCreate}>
+            <Button variant="outlined" startIcon={<AddIcon />} onClick={() => setCreateOpen(true)}>
              New template
            </Button>
          </Paper>
        ) : (
-          <Stack spacing={3}>
-            {groupedTemplates.map((group) => (
-              <Box key={group.key}>
-                <Stack direction="row" spacing={1} alignItems="center" sx={{ mb: 1 }}>
-                  <Typography variant="h6">{group.label}</Typography>
-                  <Chip size="small" label={`${group.templates.length} template${group.templates.length === 1 ? '' : 's'}`} variant="outlined" />
-                </Stack>
-                <Grid container spacing={3}>
-                  {group.templates.map((t) => {
-                    const parsed = splitTemplateTitle(t.title);
-                    return (
-                      <Grid item xs={12} sm={6} md={4} key={t.id}>
-                        <Paper
-                          elevation={2}
-                          sx={{
-                            p: 3,
-                            height: '100%',
-                            cursor: 'pointer',
-                            display: 'flex',
-                            flexDirection: 'column',
-                            gap: 1,
-                            transition: 'box-shadow 120ms',
-                            '&:hover': { boxShadow: 6 },
-                          }}
-                          onClick={() => navigate(`/exam-marker/${t.id}/setup`)}
-                        >
-                          <Box sx={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', gap: 1 }}>
-                            <Box sx={{ minWidth: 0 }}>
-                              <Typography variant="h6" sx={{ pr: 1 }}>{parsed.name}</Typography>
-                              <Chip size="small" label={parsed.version} color="info" variant="outlined" sx={{ mt: 0.5 }} />
-                            </Box>
-                            <Stack direction="row" spacing={0.5}>
-                              <Tooltip title="Rename / edit version">
-                                <IconButton size="small" onClick={(e) => openEdit(t, e)} aria-label="rename template">
-                                  <EditIcon fontSize="small" />
-                                </IconButton>
-                              </Tooltip>
-                              <Tooltip title="Duplicate as new version">
-                                <IconButton size="small" onClick={(e) => openDuplicate(t, e)} aria-label="duplicate template">
-                                  <ContentCopyIcon fontSize="small" />
-                                </IconButton>
-                              </Tooltip>
-                              <Tooltip title="Archive">
-                                <IconButton size="small" onClick={(e) => handleArchive(t, e)} aria-label="archive template">
-                                  <ArchiveIcon fontSize="small" />
-                                </IconButton>
-                              </Tooltip>
-                            </Stack>
-                          </Box>
-                          {t.subject && (
-                            <Typography variant="body2" color="text.secondary">{t.subject}</Typography>
-                          )}
-                          {t.exam_code && (
-                            <Typography variant="caption" color="text.secondary">{t.exam_code}</Typography>
-                          )}
-                          <Box sx={{ mt: 'auto', pt: 1, display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-                            <Chip size="small" label={t.status} color={STATUS_COLOR[t.status] ?? 'default'} variant="outlined" />
-                            <Typography variant="caption" color="text.secondary">
-                              Updated {new Date(t.updated_at).toLocaleDateString()}
-                            </Typography>
-                          </Box>
-                        </Paper>
-                      </Grid>
-                    );
-                  })}
-                </Grid>
-              </Box>
+          <Grid container spacing={3}>
+            {templates.map((t) => (
+              <Grid item xs={12} sm={6} md={4} key={t.id}>
+                <Paper
+                  elevation={2}
+                  sx={{ p: 3, height: '100%', cursor: 'pointer', display: 'flex', flexDirection: 'column', gap: 1,
+                        transition: 'box-shadow 120ms', '&:hover': { boxShadow: 6 } }}
+                  onClick={() => navigate(`/exam-marker/${t.id}/setup`)}
+                >
+                  <Box sx={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between' }}>
+                    <Typography variant="h6" sx={{ pr: 1 }}>{t.title}</Typography>
+                    <Tooltip title="Archive">
+                      <IconButton size="small" onClick={(e) => handleArchive(t.id, e)} aria-label="archive template">
+                        <ArchiveIcon fontSize="small" />
+                      </IconButton>
+                    </Tooltip>
+                  </Box>
+                  {t.subject && (
+                    <Typography variant="body2" color="text.secondary">{t.subject}</Typography>
+                  )}
+                  {t.exam_code && (
+                    <Typography variant="caption" color="text.secondary">{t.exam_code}</Typography>
+                  )}
+                  <Box sx={{ mt: 'auto', pt: 1, display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+                    <Chip size="small" label={t.status} color={STATUS_COLOR[t.status] ?? 'default'} variant="outlined" />
+                    <Typography variant="caption" color="text.secondary">
+                      {new Date(t.updated_at).toLocaleDateString()}
+                    </Typography>
+                  </Box>
+                  <Stack direction="row" spacing={1} sx={{ pt: 1 }}>
+                    <Button
+                      size="small"
+                      variant="outlined"
+                      onClick={(e) => { e.stopPropagation(); navigate(`/exam-marker/${t.id}/marks`); }}
+                      startIcon={<GradingIcon fontSize="small" />}
+                    >
+                      Edit marks
+                    </Button>
+                  </Stack>
+                </Paper>
+              </Grid>
            ))}
-          </Stack>
+          </Grid>
        )}
      </Stack>

-      <Dialog open={Boolean(dialog)} onClose={closeDialog} fullWidth maxWidth="sm">
-        <DialogTitle>{dialogTitle}</DialogTitle>
+      <Dialog open={createOpen} onClose={() => (saving ? null : setCreateOpen(false))} fullWidth maxWidth="sm">
+        <DialogTitle>New exam template</DialogTitle>
        <DialogContent>
          <Stack spacing={2} sx={{ mt: 1 }}>
            <TextField
-              label="Template name"
-              value={templateName}
-              onChange={(e) => setTemplateName(e.target.value)}
+              label="Title"
+              value={title}
+              onChange={(e) => setTitle(e.target.value)}
              fullWidth
              autoFocus
              required
-              helperText="User-facing name. Several templates can share the same paper."
            />
            <TextField
-              label="Version"
-              value={version}
-              onChange={(e) => setVersion(e.target.value)}
-              fullWidth
-              helperText="Stored in the template title until the API grows a dedicated version column."
-            />
-            <TextField
-              label="Paper / subject label"
+              label="Subject"
              value={subject}
              onChange={(e) => setSubject(e.target.value)}
              fullWidth
-              disabled={dialog?.mode === 'duplicate'}
            />
          </Stack>
        </DialogContent>
        <DialogActions>
-          <Button onClick={closeDialog} disabled={saving}>Cancel</Button>
-          <Button variant="contained" onClick={handleSaveDialog} disabled={saving || !templateName.trim()}>
-            {saving ? 'Saving…' : dialog?.mode === 'duplicate' ? 'Create version' : 'Save'}
+          <Button onClick={() => setCreateOpen(false)} disabled={saving}>Cancel</Button>
+          <Button variant="contained" onClick={handleCreate} disabled={saving || !title.trim()}>
+            {saving ? 'Creating…' : 'Create'}
          </Button>
        </DialogActions>
      </Dialog>
@@ -0,0 +1,501 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { useNavigate, useParams } from 'react-router-dom';
+import {
+  Alert,
+  Autocomplete,
+  Box,
+  Button,
+  Card,
+  CardContent,
+  Chip,
+  CircularProgress,
+  Container,
+  Divider,
+  FormControl,
+  Grid,
+  InputLabel,
+  MenuItem,
+  Paper,
+  Select,
+  Stack,
+  Tab,
+  Tabs,
+  TextField,
+  Typography,
+} from '@mui/material';
+import ArrowBackIcon from '@mui/icons-material/ArrowBack';
+import SaveIcon from '@mui/icons-material/Save';
+import SyncIcon from '@mui/icons-material/Sync';
+
+import { logger } from '../../debugConfig';
+import { examRepository } from '../../services/exam/examRepository';
+import type {
+  ExamQuestion,
+  ExamTemplateDetail,
+  MarkScheme,
+  MarkSchemeType,
+  SpecPoint,
+} from '../../types/exam.types';
+
+type Drafts = Record<string, PartDraft>;
+
+interface PartDraft {
+  max_marks: string;
+  answer_type: 'written' | 'mcq' | 'short' | 'diagram';
+  spec_ref: string;
+  schemeType: MarkSchemeType;
+  body: string;
+  notes: string;
+}
+
+const ANSWER_TYPES: Array<PartDraft['answer_type']> = ['written', 'short', 'mcq', 'diagram'];
+const SCHEME_TYPES: Array<{ value: MarkSchemeType; label: string; helper: string }> = [
+  { value: 'points', label: 'Points', helper: 'One mark point per line, e.g. "1 | Mentions resultant force".' },
+  { value: 'levels', label: 'Levels', helper: 'One level per line, e.g. "L2 | 3-4 | Clear linked explanation".' },
+  { value: 'parts', label: 'Parts', helper: 'One sub-part per line, e.g. "a | 2 | Correct substitution".' },
+  { value: 'checklist', label: 'Checklist', helper: 'One checklist item per line, e.g. "1 | Correct unit".' },
+  { value: 'free', label: 'Free text', helper: 'Paste or type the mark scheme exactly as it should be stored.' },
+];
+
+function deriveSpecCode(template: ExamTemplateDetail | null): string {
+  const examCode = template?.exam_code ?? '';
+  const match = examCode.match(/^([A-Z]+-[A-Z]+-\d+)/i);
+  return match?.[1] ?? '';
+}
+
+function schemeToDraft(scheme: MarkScheme | null | undefined): Pick<PartDraft, 'schemeType' | 'body' | 'notes'> {
+  const type = (scheme?.type as MarkSchemeType | undefined) ?? 'points';
+  const notes = typeof scheme?.notes === 'string' ? scheme.notes : '';
+
+  if (type === 'levels' && Array.isArray(scheme?.levels)) {
+    return {
+      schemeType: 'levels',
+      body: scheme.levels.map((l) => `${l.level ?? ''} | ${l.min ?? 0}-${l.max ?? 0} | ${l.descriptor ?? ''}`).join('\n'),
+      notes,
+    };
+  }
+  if (type === 'parts' && Array.isArray(scheme?.parts)) {
+    return {
+      schemeType: 'parts',
+      body: scheme.parts.map((p) => `${p.label ?? ''} | ${p.marks ?? 0} | ${p.guidance ?? ''}`).join('\n'),
+      notes,
+    };
+  }
+  if (type === 'checklist' && Array.isArray(scheme?.checklist)) {
+    return {
+      schemeType: 'checklist',
+      body: scheme.checklist.map((item) => `${item.marks ?? 1} | ${item.text ?? ''}`).join('\n'),
+      notes,
+    };
+  }
+  if (type === 'free') {
+    return { schemeType: 'free', body: typeof scheme?.text === 'string' ? scheme.text : '', notes };
+  }
+  if (Array.isArray(scheme?.points)) {
+    return {
+      schemeType: 'points',
+      body: scheme.points.map((p) => `${p.mark ?? 1} | ${p.text ?? ''}`).join('\n'),
+      notes,
+    };
+  }
+  return { schemeType: type, body: '', notes };
+}
+
+function parseNumber(value: string, fallback = 0): number {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function splitLine(line: string): string[] {
+  return line.split('|').map((part) => part.trim());
+}
+
+function draftToScheme(draft: PartDraft): MarkScheme {
+  const lines = draft.body.split('\n').map((line) => line.trim()).filter(Boolean);
+  if (draft.schemeType === 'free') return { type: 'free', text: draft.body, notes: draft.notes || undefined };
+  if (draft.schemeType === 'levels') {
+    return {
+      type: 'levels',
+      levels: lines.map((line, idx) => {
+        const [level, range, descriptor] = splitLine(line);
+        const [minRaw, maxRaw] = (range || '').split('-').map((part) => part.trim());
+        return {
+          level: level || `L${idx + 1}`,
+          min: parseNumber(minRaw, 0),
+          max: parseNumber(maxRaw, parseNumber(minRaw, 0)),
+          descriptor: descriptor || line,
+        };
+      }),
+      notes: draft.notes || undefined,
+    };
+  }
+  if (draft.schemeType === 'parts') {
+    return {
+      type: 'parts',
+      parts: lines.map((line, idx) => {
+        const [label, marks, guidance] = splitLine(line);
+        return { label: label || String(idx + 1), marks: parseNumber(marks, 1), guidance: guidance || line };
+      }),
+      notes: draft.notes || undefined,
+    };
+  }
+  if (draft.schemeType === 'checklist') {
+    return {
+      type: 'checklist',
+      checklist: lines.map((line) => {
+        const [marks, text] = splitLine(line);
+        return { marks: parseNumber(marks, 1), text: text || line };
+      }),
+      notes: draft.notes || undefined,
+    };
+  }
+  return {
+    type: 'points',
+    points: lines.map((line) => {
+      const [mark, text] = splitLine(line);
+      return { mark: parseNumber(mark, 1), text: text || line };
+    }),
+    notes: draft.notes || undefined,
+  };
+}
+
+function makeDraft(question: ExamQuestion): PartDraft {
+  const scheme = schemeToDraft(question.mark_scheme);
+  return {
+    max_marks: String(question.max_marks ?? 0),
+    answer_type: (question.answer_type as PartDraft['answer_type'] | null) ?? 'written',
+    spec_ref: question.spec_ref ?? '',
+    schemeType: scheme.schemeType,
+    body: scheme.body,
+    notes: scheme.notes,
+  };
+}
+
+const MarkSchemePage: React.FC = () => {
+  const navigate = useNavigate();
+  const { templateId } = useParams<{ templateId: string }>();
+
+  const [template, setTemplate] = useState<ExamTemplateDetail | null>(null);
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [drafts, setDrafts] = useState<Drafts>({});
+  const [specCode, setSpecCode] = useState('');
+  const [specPoints, setSpecPoints] = useState<SpecPoint[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [savingId, setSavingId] = useState<string | null>(null);
+  const [syncing, setSyncing] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+  const [specEndpointMissing, setSpecEndpointMissing] = useState(false);
+
+  const load = useCallback(async () => {
+    if (!templateId) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const detail = await examRepository.getTemplate(templateId);
+      const leafParts = detail.questions.filter((q) => !q.is_container).sort((a, b) => a.order - b.order || a.label.localeCompare(b.label));
+      setTemplate(detail);
+      setSelectedId((prev) => prev ?? leafParts[0]?.id ?? null);
+      setDrafts(Object.fromEntries(leafParts.map((q) => [q.id, makeDraft(q)])));
+      setSpecCode((prev) => prev || deriveSpecCode(detail));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      logger.error('cc-exam-marker', 'Failed to load mark scheme template', { message: msg, templateId });
+      setError(msg);
+    } finally {
+      setLoading(false);
+    }
+  }, [templateId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const loadSpecPoints = useCallback(async () => {
+    if (!specCode.trim()) return;
+    setSpecEndpointMissing(false);
+    try {
+      setSpecPoints(await examRepository.listSpecPoints(specCode.trim()));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      logger.warn('cc-exam-marker', 'SpecPoint endpoint unavailable; falling back to manual spec_ref entry', { message: msg, specCode });
+      setSpecEndpointMissing(true);
+      setSpecPoints([]);
+    }
+  }, [specCode]);
+
+  useEffect(() => {
+    void loadSpecPoints();
+  }, [loadSpecPoints]);
+
+  const parts = useMemo(
+    () => (template?.questions ?? []).filter((q) => !q.is_container).sort((a, b) => a.order - b.order || a.label.localeCompare(b.label)),
+    [template],
+  );
+  const selected = parts.find((p) => p.id === selectedId) ?? null;
+  const draft = selected ? drafts[selected.id] : null;
+  const selectedSpecPoint = draft?.spec_ref ? specPoints.find((p) => p.ref === draft.spec_ref) ?? null : null;
+
+  const updateDraft = (questionId: string, patch: Partial<PartDraft>) => {
+    setDrafts((prev) => ({ ...prev, [questionId]: { ...prev[questionId], ...patch } }));
+  };
+
+  const savePart = async (question: ExamQuestion) => {
+    const partDraft = drafts[question.id];
+    if (!partDraft) return;
+    setSavingId(question.id);
+    setError(null);
+    setNotice(null);
+    try {
+      await examRepository.patchQuestion(question.id, {
+        max_marks: parseNumber(partDraft.max_marks, question.max_marks),
+        answer_type: partDraft.answer_type,
+        mark_scheme: draftToScheme(partDraft),
+        spec_ref: partDraft.spec_ref.trim() || null,
+      });
+      setTemplate((prev) => {
+        if (!prev) return prev;
+        return {
+          ...prev,
+          questions: prev.questions.map((q) => q.id === question.id ? {
+            ...q,
+            max_marks: parseNumber(partDraft.max_marks, question.max_marks),
+            answer_type: partDraft.answer_type,
+            mark_scheme: draftToScheme(partDraft),
+            spec_ref: partDraft.spec_ref.trim() || null,
+          } : q),
+        };
+      });
+      setNotice(`Saved mark scheme for Part ${question.label}.`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      logger.error('cc-exam-marker', 'Save mark scheme failed', { message: msg, questionId: question.id });
+      setError(msg);
+    } finally {
+      setSavingId(null);
+    }
+  };
+
+  const syncGraph = async () => {
+    if (!templateId) return;
+    setSyncing(true);
+    setError(null);
+    setNotice(null);
+    try {
+      const res = await examRepository.syncTemplateToGraph(templateId);
+      setNotice(`Neo4j projection ${res.status}; ${JSON.stringify(res.projection ?? {})}`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      logger.error('cc-exam-marker', 'Neo4j sync failed', { message: msg, templateId });
+      setError(msg);
+    } finally {
+      setSyncing(false);
+    }
+  };
+
+  if (loading) {
+    return <Box sx={{ display: 'flex', justifyContent: 'center', py: 10 }}><CircularProgress /></Box>;
+  }
+
+  return (
+    <Container maxWidth="xl" sx={{ py: 4 }}>
+      <Stack spacing={3}>
+        <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', flexWrap: 'wrap', gap: 2 }}>
+          <Box>
+            <Button startIcon={<ArrowBackIcon />} onClick={() => navigate('/exam-marker')} sx={{ mb: 1 }}>
+              Back to templates
+            </Button>
+            <Typography variant="h3" component="h1">Mark Scheme editor</Typography>
+            <Typography variant="body1" color="text.secondary">
+              {template?.title ?? 'Template'} · Edit per-Part mark schemes and link assessed specification points.
+            </Typography>
+          </Box>
+          <Stack direction="row" spacing={1}>
+            {templateId && <Button variant="outlined" onClick={() => navigate(`/exam-marker/${templateId}/setup`)}>Setup canvas</Button>}
+            <Button variant="outlined" startIcon={<SyncIcon />} onClick={syncGraph} disabled={syncing || !templateId}>
+              {syncing ? 'Syncing…' : 'Sync to graph'}
+            </Button>
+          </Stack>
+        </Box>
+
+        {error && <Alert severity="error" onClose={() => setError(null)}>{error}</Alert>}
+        {notice && <Alert severity="success" onClose={() => setNotice(null)}>{notice}</Alert>}
+        {specEndpointMissing && (
+          <Alert severity="warning">
+            SpecPoint picker endpoint was not available from this API build. You can still type a spec_ref manually; the backend projection resolves it during neo4j-sync.
+          </Alert>
+        )}
+
+        <Paper variant="outlined" sx={{ p: 2 }}>
+          <Grid container spacing={2} alignItems="center">
+            <Grid item xs={12} md={4}>
+              <TextField
+                label="Specification code"
+                value={specCode}
+                onChange={(e) => setSpecCode(e.target.value)}
+                fullWidth
+                helperText="Example: AQA-PHYS-8463. Used by the SpecPoint picker."
+              />
+            </Grid>
+            <Grid item xs={12} md={8}>
+              <Typography variant="body2" color="text.secondary">
+                Save writes PATCH /api/exam/questions/:id. Spec refs are persisted on the Part and projected as (:Part)-[:ASSESSES]-&gt;(:SpecPoint).
+              </Typography>
+            </Grid>
+          </Grid>
+        </Paper>
+
+        {parts.length === 0 ? (
+          <Alert severity="info">
+            This template has no Parts yet. Draw Part boxes on the setup canvas first, then return here to enter mark schemes.
+          </Alert>
+        ) : (
+          <Grid container spacing={3}>
+            <Grid item xs={12} md={3}>
+              <Card variant="outlined">
+                <CardContent>
+                  <Typography variant="h6" gutterBottom>Parts</Typography>
+                  <Tabs
+                    orientation="vertical"
+                    value={selectedId ?? false}
+                    onChange={(_, value) => setSelectedId(value)}
+                    variant="scrollable"
+                    sx={{ borderRight: 1, borderColor: 'divider', maxHeight: '65vh' }}
+                  >
+                    {parts.map((part) => (
+                      <Tab
+                        key={part.id}
+                        value={part.id}
+                        label={
+                          <Box sx={{ textAlign: 'left', width: '100%' }}>
+                            <Typography variant="body2">Part {part.label}</Typography>
+                            <Stack direction="row" spacing={0.5} sx={{ mt: 0.5, flexWrap: 'wrap' }}>
+                              <Chip size="small" label={`${drafts[part.id]?.max_marks ?? part.max_marks} marks`} />
+                              {(drafts[part.id]?.spec_ref || part.spec_ref) && <Chip size="small" color="info" label={drafts[part.id]?.spec_ref || part.spec_ref || ''} />}
+                            </Stack>
+                          </Box>
+                        }
+                      />
+                    ))}
+                  </Tabs>
+                </CardContent>
+              </Card>
+            </Grid>
+
+            <Grid item xs={12} md={9}>
+              {selected && draft && (
+                <Card variant="outlined">
+                  <CardContent>
+                    <Stack spacing={3}>
+                      <Box sx={{ display: 'flex', justifyContent: 'space-between', gap: 2, flexWrap: 'wrap' }}>
+                        <Box>
+                          <Typography variant="h5">Part {selected.label}</Typography>
+                          <Typography variant="body2" color="text.secondary">
+                            {selected.parent_id ? `Parent question ${selected.parent_id}` : 'No parent question'}
+                          </Typography>
+                        </Box>
+                        <Button
+                          variant="contained"
+                          startIcon={<SaveIcon />}
+                          disabled={savingId === selected.id}
+                          onClick={() => savePart(selected)}
+                        >
+                          {savingId === selected.id ? 'Saving…' : 'Save part'}
+                        </Button>
+                      </Box>
+
+                      <Grid container spacing={2}>
+                        <Grid item xs={12} sm={4}>
+                          <TextField
+                            label="Max marks"
+                            value={draft.max_marks}
+                            onChange={(e) => updateDraft(selected.id, { max_marks: e.target.value })}
+                            type="number"
+                            inputProps={{ min: 0, step: 0.5 }}
+                            fullWidth
+                          />
+                        </Grid>
+                        <Grid item xs={12} sm={4}>
+                          <FormControl fullWidth>
+                            <InputLabel id="answer-type-label">Answer type</InputLabel>
+                            <Select
+                              labelId="answer-type-label"
+                              label="Answer type"
+                              value={draft.answer_type}
+                              onChange={(e) => updateDraft(selected.id, { answer_type: e.target.value as PartDraft['answer_type'] })}
+                            >
+                              {ANSWER_TYPES.map((type) => <MenuItem key={type} value={type}>{type}</MenuItem>)}
+                            </Select>
+                          </FormControl>
+                        </Grid>
+                        <Grid item xs={12} sm={4}>
+                          <FormControl fullWidth>
+                            <InputLabel id="scheme-type-label">Scheme form</InputLabel>
+                            <Select
+                              labelId="scheme-type-label"
+                              label="Scheme form"
+                              value={draft.schemeType}
+                              onChange={(e) => updateDraft(selected.id, { schemeType: e.target.value as MarkSchemeType })}
+                            >
+                              {SCHEME_TYPES.map((type) => <MenuItem key={type.value} value={type.value}>{type.label}</MenuItem>)}
+                            </Select>
+                          </FormControl>
+                        </Grid>
+                      </Grid>
+
+                      <Autocomplete
+                        options={specPoints}
+                        value={selectedSpecPoint}
+                        onChange={(_, value) => updateDraft(selected.id, { spec_ref: value?.ref ?? '' })}
+                        getOptionLabel={(option) => `${option.ref} — ${option.description}`}
+                        isOptionEqualToValue={(option, value) => option.ref === value.ref}
+                        renderInput={(params) => (
+                          <TextField
+                            {...params}
+                            label="SpecPoint picker"
+                            helperText={specPoints.length ? 'Choose a seeded SpecPoint, or type below to override.' : 'No picker results loaded; type spec_ref manually below.'}
+                          />
+                        )}
+                      />
+
+                      <TextField
+                        label="spec_ref"
+                        value={draft.spec_ref}
+                        onChange={(e) => updateDraft(selected.id, { spec_ref: e.target.value })}
+                        helperText="Persisted to exam_questions.spec_ref; graph sync creates the ASSESSES edge when the ref matches a seeded SpecPoint."
+                        fullWidth
+                      />
+
+                      <Divider />
+
+                      <TextField
+                        label={`${SCHEME_TYPES.find((type) => type.value === draft.schemeType)?.label ?? 'Mark scheme'} body`}
+                        value={draft.body}
+                        onChange={(e) => updateDraft(selected.id, { body: e.target.value })}
+                        helperText={SCHEME_TYPES.find((type) => type.value === draft.schemeType)?.helper}
+                        multiline
+                        minRows={10}
+                        fullWidth
+                      />
+
+                      <TextField
+                        label="Internal marking notes"
+                        value={draft.notes}
+                        onChange={(e) => updateDraft(selected.id, { notes: e.target.value })}
+                        multiline
+                        minRows={3}
+                        fullWidth
+                      />
+                    </Stack>
+                  </CardContent>
+                </Card>
+              )}
+            </Grid>
+          </Grid>
+        )}
+      </Stack>
+    </Container>
+  );
+};
+
+export default MarkSchemePage;
@@ -1 +1,2 @@
 export { default as ExamDashboardPage } from './ExamDashboardPage';
+export { default as MarkSchemePage } from './MarkSchemePage';
@@ -8,16 +8,14 @@
 import axios from 'axios';

 import { API_BASE } from '../../config/apiConfig';
-import { logger } from '../../debugConfig';
 import { supabase } from '../../supabaseClient';
 import type {
  CreateTemplatePayload,
-  ExamBoundary,
-  ExamQuestion,
-  ExamResponseArea,
  ExamTemplate,
  ExamTemplateDetail,
-  UpdateTemplateMetaPayload,
+  Neo4jSyncResult,
+  PatchQuestionPayload,
+  SpecPoint,
 } from '../../types/exam.types';

 const EXAM_BASE = `${API_BASE}/api/exam`;
@@ -30,86 +28,6 @@ async function authHeaders(): Promise<Record<string, string>> {
  return { Authorization: `Bearer ${session.access_token}` };
 }

-function newUuid(): string {
-  if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
-    return crypto.randomUUID();
-  }
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = Math.floor(Math.random() * 16);
-    const v = c === 'x' ? r : (r % 4) + 8;
-    return v.toString(16);
-  });
-}
-
-function questionPayload(q: ExamQuestion, idMap?: Map<string, string>) {
-  return {
-    id: idMap?.get(q.id) ?? q.id,
-    parent_id: q.parent_id ? (idMap?.get(q.parent_id) ?? q.parent_id) : null,
-    label: q.label,
-    order: q.order,
-    max_marks: q.max_marks,
-    answer_type: q.answer_type,
-    mcq_options: q.mcq_options,
-    mark_scheme: q.mark_scheme ?? {},
-    is_container: q.is_container,
-    spec_ref: q.spec_ref,
-    bounds: q.bounds ?? null,
-    page: q.page ?? null,
-  };
-}
-
-function responseAreaPayload(r: ExamResponseArea, idMap?: Map<string, string>, duplicate = false) {
-  return {
-    id: duplicate ? newUuid() : r.id,
-    question_id: idMap?.get(r.question_id) ?? r.question_id,
-    page: r.page,
-    bounds: r.bounds,
-    kind: r.kind,
-    response_form: r.response_form,
-    context_type: r.context_type ?? null,
-    source: r.source,
-    confirmed: r.confirmed,
-    confidence: r.confidence,
-  };
-}
-
-function boundaryPayload(b: ExamBoundary, idMap?: Map<string, string>, duplicate = false) {
-  return {
-    id: duplicate ? newUuid() : b.id,
-    question_id: b.question_id ? (idMap?.get(b.question_id) ?? b.question_id) : null,
-    label: b.label,
-    page_index: b.page_index,
-    y: b.y,
-    bounds: b.bounds,
-    source: b.source,
-    confirmed: b.confirmed,
-  };
-}
-
-async function replaceTemplate(
-  templateId: string,
-  detail: ExamTemplateDetail,
-  meta?: UpdateTemplateMetaPayload,
-  duplicateIds = false,
-): Promise<ExamTemplateDetail> {
-  const headers = await authHeaders();
-  const idMap = new Map<string, string>();
-  if (duplicateIds) {
-    detail.questions.forEach((q) => idMap.set(q.id, newUuid()));
-  }
-  const res = await axios.put<ExamTemplateDetail>(
-    `${EXAM_BASE}/templates/${templateId}`,
-    {
-      meta,
-      questions: detail.questions.map((q) => questionPayload(q, idMap)),
-      response_areas: detail.response_areas.map((r) => responseAreaPayload(r, idMap, duplicateIds)),
-      boundaries: detail.boundaries.map((b) => boundaryPayload(b, idMap, duplicateIds)),
-    },
-    { headers },
-  );
-  return res.data;
-}
-
 export const examRepository = {
  async listTemplates(includeArchived = false): Promise<ExamTemplate[]> {
    const headers = await authHeaders();
@@ -132,42 +50,32 @@ export const examRepository = {
    return res.data;
  },

-  async updateTemplateMeta(templateId: string, meta: UpdateTemplateMetaPayload): Promise<ExamTemplate> {
-    const headers = await authHeaders();
-    const res = await axios.patch<ExamTemplate>(`${EXAM_BASE}/templates/${templateId}`, meta, { headers });
-    return res.data;
-  },
-
-  async duplicateTemplate(templateId: string, title: string): Promise<ExamTemplateDetail> {
-    const detail = await this.getTemplate(templateId);
-    const created = await this.createTemplate({
-      title,
-      subject: detail.subject ?? undefined,
-      exam_id: detail.exam_id ?? undefined,
-      exam_code: detail.exam_code ?? undefined,
-      source_file_id: detail.source_file_id ?? undefined,
-      page_count: detail.page_count ?? undefined,
-      institute_id: detail.institute_id,
-    });
-    try {
-      return await replaceTemplate(created.id, { ...detail, id: created.id }, { title, status: 'draft' }, true);
-    } catch (error) {
-      try {
-        await this.archiveTemplate(created.id);
-      } catch (archiveError) {
-        logger.error('cc-exam-marker', 'Failed to archive incomplete duplicate template', {
-          templateId: created.id,
-          message: archiveError instanceof Error ? archiveError.message : String(archiveError),
-        });
-      }
-      throw error;
-    }
-  },
-
  async archiveTemplate(templateId: string): Promise<void> {
    const headers = await authHeaders();
    await axios.delete(`${EXAM_BASE}/templates/${templateId}`, { headers });
  },
+
+  async patchQuestion(questionId: string, payload: PatchQuestionPayload) {
+    const headers = await authHeaders();
+    const res = await axios.patch(`${EXAM_BASE}/questions/${questionId}`, payload, { headers });
+    return res.data;
+  },
+
+  async listSpecPoints(specCode: string, search?: string): Promise<SpecPoint[]> {
+    const headers = await authHeaders();
+    const res = await axios.get<{ points?: SpecPoint[] } | SpecPoint[]>(
+      `${EXAM_BASE}/specs/${encodeURIComponent(specCode)}/points`,
+      { headers, params: search ? { q: search } : undefined },
+    );
+    if (Array.isArray(res.data)) return res.data;
+    return res.data.points ?? [];
+  },
+
+  async syncTemplateToGraph(templateId: string): Promise<Neo4jSyncResult> {
+    const headers = await authHeaders();
+    const res = await axios.post<Neo4jSyncResult>(`${EXAM_BASE}/templates/${templateId}/neo4j-sync`, {}, { headers });
+    return res.data;
+  },
 };

 export default examRepository;
@@ -31,11 +31,40 @@ export interface CreateTemplatePayload {
  institute_id?: string;
 }

-export interface UpdateTemplateMetaPayload {
-  title?: string;
-  subject?: string | null;
-  page_count?: number | null;
-  status?: ExamTemplateStatus;
+export type MarkSchemeType = 'points' | 'levels' | 'parts' | 'checklist' | 'free';
+
+export interface MarkSchemePoint {
+  mark: number;
+  text: string;
+}
+
+export interface MarkSchemeLevel {
+  level: string;
+  min: number;
+  max: number;
+  descriptor: string;
+}
+
+export interface MarkSchemePart {
+  label: string;
+  marks: number;
+  guidance: string;
+}
+
+export interface MarkSchemeChecklistItem {
+  text: string;
+  marks: number;
+}
+
+export interface MarkScheme {
+  type?: MarkSchemeType;
+  points?: MarkSchemePoint[];
+  levels?: MarkSchemeLevel[];
+  parts?: MarkSchemePart[];
+  checklist?: MarkSchemeChecklistItem[];
+  text?: string;
+  notes?: string;
+  [key: string]: unknown;
 }

 /** Canvas children (used from S4-9 onward; defined here so the seam is complete). */
@@ -48,28 +77,20 @@ export interface ExamQuestion {
  max_marks: number;
  answer_type: string | null;
  mcq_options: unknown | null;
-  mark_scheme: Record<string, unknown>;
+  mark_scheme: MarkScheme;
  is_container: boolean;
  spec_ref: string | null;
  bounds?: Record<string, number> | null;
  page?: number | null;
 }

-export type ExamResponseAreaKind =
-  | 'response'
-  | 'context'
-  | 'question_number'
-  | 'mark_area'
-  | 'reference'
-  | 'furniture';
-
 export interface ExamResponseArea {
  id: string;
  question_id: string;
  template_id: string;
  page: number;
  bounds: Record<string, number>;
-  kind: ExamResponseAreaKind;
+  kind: 'response' | 'context' | 'question_number' | 'mark_area' | 'reference' | 'furniture';
  response_form: string | null;
  context_type?: string | null;
  source: 'manual' | 'ai';
@@ -94,3 +115,28 @@ export interface ExamTemplateDetail extends ExamTemplate {
  response_areas: ExamResponseArea[];
  boundaries: ExamBoundary[];
 }
+
+export interface PatchQuestionPayload {
+  label?: string;
+  order?: number;
+  max_marks?: number;
+  answer_type?: 'written' | 'mcq' | 'short' | 'diagram' | null;
+  mcq_options?: unknown;
+  mark_scheme?: MarkScheme;
+  is_container?: boolean;
+  spec_ref?: string | null;
+}
+
+export interface SpecPoint {
+  uid?: string;
+  uuid_string?: string;
+  ref: string;
+  description: string;
+  spec_code: string;
+  exam_board_code?: string;
+}
+
+export interface Neo4jSyncResult {
+  status: string;
+  projection?: Record<string, unknown>;
+}