diff --git a/database/mariadb.js b/database/mariadb.js
index c03760f..245f790 100644
--- a/database/mariadb.js
+++ b/database/mariadb.js
@@ -100,11 +100,40 @@ const createTables = async () => {
         player_count INT NOT NULL DEFAULT 3,
         scenes JSON DEFAULT ('[]'),
         gm_player VARCHAR(255),
+        is_active TINYINT(1) NOT NULL DEFAULT 0,
+        current_scene INT NOT NULL DEFAULT 0,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
       )
     `);
 
+    // Shared mission roll log for GM visibility
+    await connection.execute(`
+      CREATE TABLE IF NOT EXISTS mission_rolls (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        mission_id INT,
+        player_name VARCHAR(255),
+        roll_type VARCHAR(50) NOT NULL DEFAULT 'check',
+        scene_index INT NOT NULL DEFAULT 0,
+        label VARCHAR(500),
+        payload JSON DEFAULT ('{}'),
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        INDEX idx_mission_rolls_mission_created (mission_id, created_at)
+      )
+    `);
+
+    try {
+      await connection.execute(`ALTER TABLE missions ADD COLUMN is_active TINYINT(1) NOT NULL DEFAULT 0`);
+    } catch (error) {
+      if (error.code !== 'ER_DUP_FIELDNAME') throw error;
+    }
+
+    try {
+      await connection.execute(`ALTER TABLE missions ADD COLUMN current_scene INT NOT NULL DEFAULT 0`);
+    } catch (error) {
+      if (error.code !== 'ER_DUP_FIELDNAME') throw error;
+    }
+
     await connection.execute(`CREATE INDEX IF NOT EXISTS idx_missions_created_at ON missions(created_at)`);
     await connection.execute(`CREATE INDEX IF NOT EXISTS idx_missions_theme ON missions(theme)`);
 
@@ -468,6 +497,8 @@ const missionHelpers = {
       const [rows] = await pool.execute('SELECT * FROM missions ORDER BY created_at DESC');
       return rows.map(row => ({
         ...row,
+        is_active: Boolean(row.is_active),
+        current_scene: row.current_scene || 0,
         scenes: typeof row.scenes === 'string' ? JSON.parse(row.scenes) : row.scenes
       }));
     } catch (error) {
@@ -483,6 +514,8 @@ const missionHelpers = {
       const row = rows[0];
       return {
         ...row,
+        is_active: Boolean(row.is_active),
+        current_scene: row.current_scene || 0,
         scenes: typeof row.scenes === 'string' ? JSON.parse(row.scenes) : row.scenes
       };
     } catch (error) {
@@ -521,6 +554,64 @@ const missionHelpers = {
     }
   },
 
+  getActive: async () => {
+    try {
+      const [rows] = await pool.execute('SELECT * FROM missions WHERE is_active = 1 ORDER BY updated_at DESC LIMIT 1');
+      if (rows.length === 0) return null;
+      const row = rows[0];
+      return {
+        ...row,
+        is_active: Boolean(row.is_active),
+        current_scene: row.current_scene || 0,
+        scenes: typeof row.scenes === 'string' ? JSON.parse(row.scenes) : row.scenes
+      };
+    } catch (error) {
+      logToFile('MariaDB: Error getting active mission', error);
+      return null;
+    }
+  },
+
+  setActive: async (id) => {
+    const connection = await pool.getConnection();
+    try {
+      await connection.beginTransaction();
+      const [existing] = await connection.execute('SELECT id FROM missions WHERE id = ? LIMIT 1', [id]);
+      if (existing.length === 0) {
+        await connection.rollback();
+        return false;
+      }
+      await connection.execute('UPDATE missions SET is_active = 0');
+      const [result] = await connection.execute(
+        'UPDATE missions SET is_active = 1, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
+        [id]
+      );
+      await connection.commit();
+      logToFile('MariaDB: Set active mission', id);
+      return result.affectedRows > 0;
+    } catch (error) {
+      await connection.rollback();
+      logToFile('MariaDB: Error setting active mission', id, error);
+      return false;
+    } finally {
+      connection.release();
+    }
+  },
+
+  updateProgress: async (id, progressData) => {
+    try {
+      const { currentScene, scenes } = progressData;
+      const [result] = await pool.execute(
+        'UPDATE missions SET current_scene = ?, scenes = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
+        [Number.isInteger(currentScene) ? currentScene : 0, JSON.stringify(scenes || []), id]
+      );
+      logToFile('MariaDB: Updated mission progress', id);
+      return result.affectedRows > 0;
+    } catch (error) {
+      logToFile('MariaDB: Error updating mission progress', id, error);
+      return false;
+    }
+  },
+
   delete: async (id) => {
     try {
       const [result] = await pool.execute('DELETE FROM missions WHERE id = ?', [id]);
@@ -533,6 +624,69 @@ const missionHelpers = {
   }
 };
 
+const missionRollHelpers = {
+  create: async (rollData) => {
+    try {
+      let missionId = rollData.missionId || rollData.mission_id || null;
+      let sceneIndex = Number.isInteger(rollData.sceneIndex) ? rollData.sceneIndex : Number(rollData.scene_index || 0);
+      if (!missionId) {
+        const active = await missionHelpers.getActive();
+        missionId = active?.id || null;
+        sceneIndex = active?.current_scene || sceneIndex || 0;
+      }
+      const payload = rollData.payload && typeof rollData.payload === 'object' ? rollData.payload : {};
+      const [result] = await pool.execute(
+        'INSERT INTO mission_rolls (mission_id, player_name, roll_type, scene_index, label, payload) VALUES (?, ?, ?, ?, ?, ?)',
+        [
+          missionId,
+          rollData.playerName || rollData.player_name || 'unknown',
+          rollData.rollType || rollData.roll_type || 'check',
+          Number.isFinite(sceneIndex) ? sceneIndex : 0,
+          rollData.label || payload.name || payload.weapon || null,
+          JSON.stringify(payload),
+        ]
+      );
+      return result.insertId;
+    } catch (error) {
+      logToFile('MariaDB: Error creating mission roll', error);
+      return null;
+    }
+  },
+
+  getForMission: async (missionId, limit = 50) => {
+    try {
+      const boundedLimit = Math.max(1, Math.min(Number(limit) || 50, 100));
+      const [rows] = await pool.execute(
+        `SELECT * FROM mission_rolls WHERE mission_id = ? ORDER BY created_at DESC LIMIT ${boundedLimit}`,
+        [missionId]
+      );
+      return rows.map(row => ({
+        ...row,
+        payload: typeof row.payload === 'string' ? JSON.parse(row.payload || '{}') : row.payload,
+      }));
+    } catch (error) {
+      logToFile('MariaDB: Error getting mission rolls', missionId, error);
+      return [];
+    }
+  },
+
+  getActive: async (limit = 50) => {
+    const active = await missionHelpers.getActive();
+    if (!active) return [];
+    return missionRollHelpers.getForMission(active.id, limit);
+  },
+
+  delete: async (id) => {
+    try {
+      const [result] = await pool.execute('DELETE FROM mission_rolls WHERE id = ?', [id]);
+      return result.affectedRows > 0;
+    } catch (error) {
+      logToFile('MariaDB: Error deleting mission roll', id, error);
+      return false;
+    }
+  }
+};
+
 // Initialize database
 createTables().catch(error => {
   console.error('Failed to initialize MariaDB:', error);
@@ -549,5 +703,6 @@ module.exports = {
   weaponsHelpers,
   bestiaryHelpers,
   missionHelpers,
+  missionRollHelpers,
   logToFile
 };
diff --git a/database/routes/missionRoutes.js b/database/routes/missionRoutes.js
index df25bfe..2c18e73 100644
--- a/database/routes/missionRoutes.js
+++ b/database/routes/missionRoutes.js
@@ -1,7 +1,22 @@
 const express = require('express');
-const { missionHelpers, logToFile } = require('../mariadb');
+const { missionHelpers, missionRollHelpers, logToFile } = require('../mariadb');
 const router = express.Router();
 
+function playerScene(scene) {
+  if (!scene || typeof scene !== 'object') return null;
+  const {
+    gmNotes,
+    gm_notes,
+    secret,
+    secrets,
+    hidden,
+    gmOnly,
+    gm_only,
+    ...safeScene
+  } = scene;
+  return safeScene;
+}
+
 // Get all missions
 router.get('/', async (req, res) => {
   try {
@@ -13,6 +28,75 @@ router.get('/', async (req, res) => {
   }
 });
 
+// Get active mission for the shared play table
+router.get('/active/current', async (req, res) => {
+  try {
+    const mission = await missionHelpers.getActive();
+    res.json(mission || null);
+  } catch (error) {
+    logToFile('API: Failed to get active mission', error);
+    res.status(500).json({ error: String(error) });
+  }
+});
+
+// Get player-safe active mission. Only the GM-current scene is returned.
+router.get('/active/player', async (req, res) => {
+  try {
+    const mission = await missionHelpers.getActive();
+    if (!mission) return res.json(null);
+
+    const scenes = Array.isArray(mission.scenes) ? mission.scenes : [];
+    const currentIndex = Math.max(0, Math.min(Number(mission.current_scene || 0), Math.max(scenes.length - 1, 0)));
+    const currentScene = scenes[currentIndex] || null;
+
+    res.json({
+      id: mission.id,
+      name: mission.name,
+      current_scene: 0,
+      active_scene_index: currentIndex,
+      scenes: currentScene ? [playerScene(currentScene)] : [],
+    });
+  } catch (error) {
+    logToFile('API: Failed to get player active mission', error);
+    res.status(500).json({ error: String(error) });
+  }
+});
+
+// Get roll feed for the active mission
+router.get('/active/rolls/feed', async (req, res) => {
+  try {
+    const rolls = await missionRollHelpers.getActive(Number(req.query.limit || 50));
+    res.json(rolls);
+  } catch (error) {
+    logToFile('API: Failed to get active mission rolls', error);
+    res.status(500).json({ error: String(error) });
+  }
+});
+
+// Record a roll for GM visibility
+router.post('/rolls', async (req, res) => {
+  try {
+    const id = await missionRollHelpers.create(req.body || {});
+    if (!id) return res.status(500).json({ error: 'Failed to record roll' });
+    res.json({ success: true, id });
+  } catch (error) {
+    logToFile('API: Failed to record mission roll', error);
+    res.status(500).json({ error: String(error) });
+  }
+});
+
+// Delete a roll from the mission feed
+router.delete('/rolls/:id', async (req, res) => {
+  try {
+    const ok = await missionRollHelpers.delete(req.params.id);
+    if (!ok) return res.status(404).json({ error: 'Roll not found' });
+    res.json({ success: true });
+  } catch (error) {
+    logToFile('API: Failed to delete mission roll', req.params.id, error);
+    res.status(500).json({ error: String(error) });
+  }
+});
+
 // Get mission by ID
 router.get('/:id', async (req, res) => {
   try {
@@ -38,6 +122,32 @@ router.post('/', async (req, res) => {
   }
 });
 
+// Set active mission
+router.post('/:id/active', async (req, res) => {
+  try {
+    const ok = await missionHelpers.setActive(req.params.id);
+    if (!ok) return res.status(404).json({ error: 'Mission not found' });
+    const mission = await missionHelpers.getById(req.params.id);
+    res.json({ success: true, mission });
+  } catch (error) {
+    logToFile('API: Failed to set active mission', req.params.id, error);
+    res.status(500).json({ error: String(error) });
+  }
+});
+
+// Update active play progress
+router.put('/:id/progress', async (req, res) => {
+  try {
+    const ok = await missionHelpers.updateProgress(req.params.id, req.body || {});
+    if (!ok) return res.status(404).json({ error: 'Mission not found' });
+    const mission = await missionHelpers.getById(req.params.id);
+    res.json({ success: true, mission });
+  } catch (error) {
+    logToFile('API: Failed to update mission progress', req.params.id, error);
+    res.status(500).json({ error: String(error) });
+  }
+});
+
 // Update mission
 router.put('/:id', async (req, res) => {
   try {
diff --git a/database/routes/playerRoutes.js b/database/routes/playerRoutes.js
index 4290d5a..608d8eb 100644
--- a/database/routes/playerRoutes.js
+++ b/database/routes/playerRoutes.js
@@ -1,7 +1,17 @@
 const express = require('express');
+const bcrypt = require('bcrypt');
 const { playerHelpers, logToFile } = require('../mariadb');
 const router = express.Router();
 
+async function isValidPlayerPassword(player, password) {
+  if (player.pwHash) {
+    return bcrypt.compare(password, player.pwHash);
+  }
+
+  const expectedPassword = player.pw || process.env.PLAYER_PASSWORD || '1234';
+  return password === expectedPassword;
+}
+
 // Login endpoint for players
 router.post('/login', async (req, res) => {
   try {
@@ -26,9 +36,7 @@ router.post('/login', async (req, res) => {
         return res.status(401).json({ error: 'Invalid username or password' });
       }
     } else {
-      // For regular players, use environment variable or default
-      const playerPassword = process.env.PLAYER_PASSWORD || 'defaultpassword';
-      if (password !== playerPassword) {
+      if (!(await isValidPlayerPassword(player, password))) {
         return res.status(401).json({ error: 'Invalid username or password' });
       }
     }
diff --git a/database/routes/sessionRoutes.js b/database/routes/sessionRoutes.js
index 07dd70f..b721741 100644
--- a/database/routes/sessionRoutes.js
+++ b/database/routes/sessionRoutes.js
@@ -1,5 +1,6 @@
 const express = require('express');
 const { logToFile } = require('../mariadb');
+const { validateSession, deleteSession } = require('../sessionModel');
 const router = express.Router();
 
 // Simple session validation endpoint
@@ -12,14 +13,13 @@ router.post('/validate', async (req, res) => {
       return res.status(400).json({ error: 'sessionId required' });
     }
     
-    // Extract player name from session ID (format: session_playername_timestamp_random)
-    const match = sessionId.match(/^session_([^_]+)_\d+_[a-z0-9]+$/);
-    if (!match) {
-      logToFile('SESSION: Invalid session format', sessionId);
-      return res.status(401).json({ error: 'Invalid session format' });
+    const session = await validateSession(sessionId);
+    if (!session || !session.data || !session.data.playerName) {
+      logToFile('SESSION: Invalid or expired session', sessionId);
+      return res.status(401).json({ error: 'Invalid or expired session' });
     }
     
-    const playerName = match[1];
+    const playerName = session.data.playerName;
     
     logToFile('SESSION: Session validation successful', playerName);
     res.json({ 
@@ -38,6 +38,7 @@ router.post('/logout', async (req, res) => {
   try {
     const { sessionId } = req.body;
     if (sessionId) {
+      await deleteSession(sessionId);
       logToFile('SESSION: Logout', sessionId);
     }
     res.json({ success: true });
@@ -47,5 +48,5 @@ router.post('/logout', async (req, res) => {
   }
 });
 
-console.log('Session routes registered (simple validation)');
+console.log('Session routes registered');
 module.exports = router;
diff --git a/src/App.js b/src/App.js
index bf18637..fff8aa9 100755
--- a/src/App.js
+++ b/src/App.js
@@ -8,7 +8,7 @@ import BestiaryTab from './components/BestiaryTab';
 import WeaponsTab from './components/WeaponsTab';
 import GMKit from './components/GMKit';
 import PlayerManagement from './components/PlayerManagement';
-import MissionSimTab from './components/MissionSimTab';
+import MissionTab from './components/MissionTab';
 import { useState, useEffect } from 'react';
 import axios from 'axios';
 import { debug, info, warn, error, logApiCall, logApiError, logUserAction } from './utils/logger';
@@ -44,6 +44,14 @@ function App() {
     fetchPlayers();
   }, []);
 
+  useEffect(() => {
+    function openRollerFromMission() {
+      setTab('roller');
+    }
+    window.addEventListener('dw:open-roller', openRollerFromMission);
+    return () => window.removeEventListener('dw:open-roller', openRollerFromMission);
+  }, []);
+
   // Validate session on mount/refresh
   useEffect(() => {
     async function validate() {
@@ -245,7 +253,7 @@ function App() {
                     type="text"
                     placeholder="Username"
                     value={loginName}
-                    onChange={e=>{setLoginName(e.target.value); setLoginPw(e.target.value==='gm'?'bongo':'1234');}}
+                    onChange={e=>{setLoginName(e.target.value); setLoginPw(e.target.value==='gm'?'':'1234');}}
                     data-testid="login-user-input"
                   />
                   <input 
@@ -371,7 +379,7 @@ function App() {
               {players && players.length > 0 ? players.map(player => (
                 <button
                   key={player.name}
-                  onClick={() => {setLoginName(player.name); setLoginPw(player.name==='gm'?'bongo':'1234');}}
+                  onClick={() => {setLoginName(player.name); setLoginPw(player.name==='gm'?'':'1234');}}
                   className="px-2 py-1 rounded bg-blue-700/30 text-blue-200 hover:bg-blue-600/40 transition-colors"
                 >
                   {player.name}
@@ -380,11 +388,11 @@ function App() {
                 <div className="text-xs text-blue-200/60">No users found. Click Refresh or check backend.</div>
               )}
             </div>
-            <p className="text-xs text-blue-300/70 mt-2">Players: <code className="bg-blue-800/40 px-1 rounded">1234</code> | GM: <code className="bg-blue-800/40 px-1 rounded">bongo</code></p>
+            <p className="text-xs text-blue-300/70 mt-2">Player password is auto-filled. GM password must be entered manually.</p>
           </div>
         )}
         
-  {tab==='roller' ? <DeathwatchRoller /> : tab==='shop' ? <RequisitionShop authedPlayer={authedPlayer} sessionId={sessionId} /> : tab==='rules' ? <RulesTab authedPlayer={authedPlayer} sessionId={sessionId} /> : tab==='weapons' ? <WeaponsTab /> : tab==='bestiary' ? (authedPlayer === 'gm' ? <BestiaryTab /> : <div className="p-6 rounded-lg bg-red-900/20 border border-red-500/30"><h2 className="text-xl font-bold text-red-300 mb-2">Access Denied</h2><p className="text-red-200">The Bestiary is only accessible to Game Masters. Please log in with a GM account.</p></div>) : tab==='players' ? <PlayerManagement authedPlayer={authedPlayer} sessionId={sessionId} /> : tab==='gmkit' ? <GMKit authedPlayer={authedPlayer} /> : tab==='mission' ? (authedPlayer === 'gm' ? <MissionSimTab authedPlayer={authedPlayer} /> : <div className="p-6 rounded-lg bg-red-900/20 border border-red-500/30"><h2 className="text-xl font-bold text-red-300 mb-2">Access Denied</h2><p className="text-red-200">Mission is only accessible to Game Masters. Please log in with a GM account.</p></div>) : <PlayerTab
+  {tab==='roller' ? <DeathwatchRoller authedPlayer={authedPlayer} /> : tab==='shop' ? <RequisitionShop authedPlayer={authedPlayer} sessionId={sessionId} /> : tab==='rules' ? <RulesTab authedPlayer={authedPlayer} sessionId={sessionId} /> : tab==='weapons' ? <WeaponsTab /> : tab==='bestiary' ? (authedPlayer === 'gm' ? <BestiaryTab /> : <div className="p-6 rounded-lg bg-red-900/20 border border-red-500/30"><h2 className="text-xl font-bold text-red-300 mb-2">Access Denied</h2><p className="text-red-200">The Bestiary is only accessible to Game Masters. Please log in with a GM account.</p></div>) : tab==='players' ? <PlayerManagement authedPlayer={authedPlayer} sessionId={sessionId} /> : tab==='gmkit' ? <GMKit authedPlayer={authedPlayer} /> : tab==='mission' ? <MissionTab authedPlayer={authedPlayer} /> : <PlayerTab
           authedPlayer={authedPlayer} 
           sessionId={sessionId}
         />}
@@ -393,4 +401,4 @@ function App() {
   );
 }
 
-export default App;
\ No newline at end of file
+export default App;
diff --git a/src/components/DeathwatchRoller.jsx b/src/components/DeathwatchRoller.jsx
index 944d125..479b72f 100755
--- a/src/components/DeathwatchRoller.jsx
+++ b/src/components/DeathwatchRoller.jsx
@@ -1,4 +1,5 @@
-import React, { useEffect, useMemo, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { MISSION_ROLL_CONTEXT_KEY } from '../utils/diceRoller';
 
 // Tooltip component for abbreviations
 function Tooltip({ children, text }) {
@@ -297,7 +298,7 @@ function computeWeaponDefaults(w) { return { damage: w.damage, tearing: !!w.tear
 
 function uid() { return Math.random().toString(36).slice(2) + Date.now().toString(36) }
 
-function DeathwatchRoller() {
+function DeathwatchRoller({ authedPlayer }) {
   const [bs,setBS] = useState(45)
   const [ws,setWS] = useState(45)
   const [defenderBS, setDefenderBS] = useState(45)
@@ -421,6 +422,9 @@ function DeathwatchRoller() {
   const [history,setHistory] = useState(()=> safeGet(STORAGE_HISTORY) ?? [])
   const [error,setError] = useState('')
   const [info,setInfo] = useState('')
+  const [combatRound, setCombatRound] = useState(() => {
+    try { const s = JSON.parse(localStorage.getItem('dw:combat-state') || 'null'); return s || null; } catch { return null; }
+  })
   const [progressStep, setProgressStep] = useState('idle') // idle | attack | defense | damage | wounds
   const [lastAppliedDamage, setLastAppliedDamage] = useState(0)
   
@@ -430,6 +434,29 @@ function DeathwatchRoller() {
   const [manualDefenseRoll, setManualDefenseRoll] = useState('')
   const [manualDamageRolls, setManualDamageRolls] = useState('')
 
+  const applyMissionContext = useCallback((ctx) => {
+    if (!ctx || typeof ctx !== 'object') return
+    if (typeof ctx.bs === 'number') setBS(ctx.bs)
+    if (typeof ctx.ws === 'number') setWS(ctx.ws)
+    if (typeof ctx.modifier === 'number') setModifier(ctx.modifier)
+    if (typeof ctx.aim === 'number') setAim(ctx.aim)
+    if (ctx.mode) setMode(ctx.mode)
+    if (typeof ctx.rof === 'number') setRof(ctx.rof)
+    if (ctx.damage) setDamage(ctx.damage)
+    if (typeof ctx.tearing === 'boolean') setTearing(ctx.tearing)
+    if (typeof ctx.proven === 'number') setProven(ctx.proven)
+    if (typeof ctx.pen === 'number') setPen(ctx.pen)
+    if (typeof ctx.reliable === 'boolean') setReliable(ctx.reliable)
+    if (typeof ctx.targetTB === 'number') setTargetTB(ctx.targetTB)
+    if (typeof ctx.targetArmour === 'number') {
+      setTargetArmour(ctx.targetArmour)
+      setArmourMap(uniformArmourMap(ctx.targetArmour))
+    }
+    if (ctx.weapon) setWeaponName(ctx.weapon)
+    if (ctx.enemy) setEnemyName(ctx.enemy)
+    setInfo(`Loaded mission roll context${ctx.sceneTitle ? `: ${ctx.sceneTitle}` : ''}`)
+  }, [])
+
   const usingSkill = useMemo(()=>{ const w = weapons.find(x=>x.name===weaponName); if (!w) return 'BS'; return w.class==='melee' ? 'WS' : 'BS' },[weaponName, weapons])
   const diffMod = useMemo(()=>{ if (difficulty==='easy') return 20; if (difficulty==='hard') return -20; if (difficulty==='deadly') return -30; return 0 },[difficulty])
   const baseSkill = useMemo(()=> usingSkill === 'BS' ? bs : ws, [usingSkill, bs, ws])
@@ -441,6 +468,24 @@ function DeathwatchRoller() {
   // Removed localStorage persistence - using database API instead
   useEffect(()=>{ safeSet(STORAGE_TRACKER, { maxWounds, curWounds, partDamage }) },[maxWounds, curWounds, partDamage])
 
+  useEffect(() => {
+    function readContext() {
+      const ctx = safeGet(MISSION_ROLL_CONTEXT_KEY)
+      if (ctx) applyMissionContext(ctx)
+    }
+    readContext()
+    window.addEventListener('dw:mission-roll-context', readContext)
+    return () => window.removeEventListener('dw:mission-roll-context', readContext)
+  }, [applyMissionContext])
+
+  useEffect(() => {
+    function onCombatState(e) {
+      setCombatRound(e.detail || null)
+    }
+    window.addEventListener('dw:combat-state', onCombatState)
+    return () => window.removeEventListener('dw:combat-state', onCombatState)
+  }, [])
+
   // On first run, if there are no stored weapons try to fetch the packaged DB from public
   useEffect(()=>{
     (async () => {
@@ -700,7 +745,7 @@ function DeathwatchRoller() {
 
     // Attack failed - no damage
     const res = { id: uid(), ts: Date.now(), attackRoll, target, success: dg.success, dos: dg.dos, dof: dg.dof, mode, rof, hits: 0, where, jammed, perHit: [], weapon: weaponName || undefined, enemy: enemyName || undefined, using: usingSkill }
-    setHistory(prev => [res, ...prev].slice(0, 50))
+    addRollResult(res)
     setInfo(`Attack missed with DoF ${dg.dof}`)
     // Clear progress after a short delay
     setTimeout(()=> setProgressStep('idle'), 1200)
@@ -801,7 +846,7 @@ function DeathwatchRoller() {
         mode: pendingHits.mode,
         rof: pendingHits.rof
       }
-      setHistory(prev => [res, ...prev].slice(0, 50))
+      addRollResult(res)
       setAwaitingDefense(false)
       setPendingHits(null)
       setReactionUsed(true)
@@ -884,7 +929,7 @@ function DeathwatchRoller() {
       rof: pendingHits.rof
     }
     
-    setHistory(prev => [res, ...prev].slice(0, 50))
+    addRollResult(res)
       if (totalApplied>0) {
       const applied = Math.max(0, Math.floor(totalApplied))
       setPartDamage(nextParts)
@@ -917,6 +962,24 @@ function DeathwatchRoller() {
   const status = curWounds<=0 ? 'Dead' : (curWounds<maxWounds ? 'Wounded' : 'Alive')
   const statusColor = status==='Dead' ? 'bg-rose-600' : status==='Wounded' ? 'bg-amber-500' : 'bg-emerald-600'
 
+  function addRollResult(result) {
+    setHistory(prev => [result, ...prev].slice(0, 50))
+    try {
+      fetch('/api/missions/rolls', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          playerName: authedPlayer || 'unknown',
+          rollType: 'combat',
+          label: result.weapon || result.enemy || 'Dice Roller',
+          payload: result,
+        }),
+      }).catch(() => {});
+    } catch (e) {
+      // Local roll history still works if the shared mission feed is unavailable.
+    }
+  }
+
   return (
     <section className="min-h-screen bg-gradient-to-br from-slate-900 via-slate-800 to-slate-900 text-slate-100 p-6 md:p-10">
       <div className="mx-auto max-w-6xl space-y-6">
@@ -928,6 +991,9 @@ function DeathwatchRoller() {
         <div className="flex items-center justify-between">
           <h1 className="text-3xl md:text-4xl font-extrabold tracking-tight">Deathwatch Roller Pro</h1>
           <div className="flex items-center gap-3">
+            {combatRound?.active && (
+              <span className="text-xs px-2 py-1 rounded bg-red-700 text-red-100 font-bold">Round {combatRound.round}</span>
+            )}
             <div className="text-xs uppercase tracking-wide opacity-70">Target {target} • {usingSkill}</div>
             <span className={`text-xs px-2 py-1 rounded ${statusColor}`}>{status}</span>
             <button 
@@ -1082,7 +1148,7 @@ function DeathwatchRoller() {
                       rof: pendingHits.rof
                     }
                     
-                    setHistory(prev => [res, ...prev].slice(0, 50))
+                    addRollResult(res)
                     if (totalApplied>0) {
                       setPartDamage(nextParts)
                       setCurWounds(w => Math.max(0, w - totalApplied))
diff --git a/src/components/MissionTab.jsx b/src/components/MissionTab.jsx
index 1dd9a1f..7f90b75 100644
--- a/src/components/MissionTab.jsx
+++ b/src/components/MissionTab.jsx
@@ -1,129 +1,1587 @@
-import React, { useState, useEffect } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import axios from 'axios';
+import { MISSION_ROLL_CONTEXT_KEY, clampTarget, d100, degrees } from '../utils/diceRoller';
 
-function MissionTab({ authedPlayer }) {
-  const [history, setHistory] = useState([]);
+const COMBAT_STATE_KEY = 'dw:combat-state';
+
+function titleForScene(scene, index) {
+  return scene?.title || scene?.name || `Scene ${index + 1}`;
+}
+
+function textForScene(scene) {
+  return scene?.description || scene?.briefing || scene?.summary || '';
+}
+
+function listForScene(scene, key) {
+  return Array.isArray(scene?.[key]) ? scene[key] : [];
+}
+
+function defaultChecksForScene(scene) {
+  const type = String(scene?.type || '').toLowerCase();
+  if (type.includes('combat')) {
+    return [
+      { name: 'Identify priority target', skill: 'Awareness', characteristic: 'Per', target: 45, modifier: 0, reward: 'Learn the most dangerous enemy or ambush vector.' },
+      { name: 'Hold firing position', skill: 'Dodge', characteristic: 'Ag', target: 45, modifier: -10, reward: 'Avoid being driven out of cover this round.' },
+    ];
+  }
+  if (type.includes('investigation') || type.includes('puzzle')) {
+    return [
+      { name: 'Read the spoor and auspex ghosts', skill: 'Awareness', characteristic: 'Per', target: 45, modifier: 0, reward: 'Reveal the next clue or hidden movement.' },
+      { name: 'Decode corrupted systems', skill: 'Tech-Use', characteristic: 'Int', target: 45, modifier: -10, reward: 'Recover data before the trail degrades.' },
+    ];
+  }
+  if (type.includes('social')) {
+    return [
+      { name: 'Stabilise frightened survivors', skill: 'Command', characteristic: 'Fel', target: 45, modifier: 0, reward: 'Gain cooperation and a useful witness detail.' },
+      { name: 'Interrogate conflicting accounts', skill: 'Scrutiny', characteristic: 'Per', target: 45, modifier: -10, reward: 'Separate panic from truth.' },
+    ];
+  }
+  return [
+    { name: 'Maintain tactical awareness', skill: 'Awareness', characteristic: 'Per', target: 45, modifier: 0, reward: 'Spot the next useful detail.' },
+    { name: 'Coordinate the kill-team', skill: 'Command', characteristic: 'Fel', target: 45, modifier: 0, reward: 'Grant a clear tactical direction.' },
+  ];
+}
+
+function combatForScene(scene) {
+  if (scene?.combat && typeof scene.combat === 'object') return scene.combat;
+  const enemies = sceneEnemies(scene);
+  return {
+    enemy: enemies[0] || 'Custom/None',
+    weapon: '',
+    bs: 45,
+    ws: 45,
+    modifier: String(scene?.type || '').toLowerCase().includes('combat') ? 0 : -10,
+    damage: '1d10+5',
+    targetTB: 4,
+    targetArmour: 5,
+    mode: 'single',
+    rof: 1,
+  };
+}
+
+function missionTheme(mission) {
+  return mission?.theme ? String(mission.theme).replace(/_/g, ' ') : 'Unassigned';
+}
+
+function sceneEnemies(scene) {
+  if (!Array.isArray(scene?.enemies)) return [];
+  return scene.enemies.map(enemy => enemy.name || enemy.type || 'Unknown enemy');
+}
+
+function normalizeMission(mission) {
+  if (!mission) return null;
+  const scenes = Array.isArray(mission.scenes) ? mission.scenes : [];
+  const currentScene = Math.max(0, Math.min(Number(mission.current_scene || 0), Math.max(scenes.length - 1, 0)));
+  return { ...mission, scenes, current_scene: currentScene };
+}
+
+const CONDITIONS = ['Pinned', 'Stunned', 'Bleeding', 'Grappled', 'Knocked Down', 'Fatigued'];
+
+const FEAR_RATINGS = [
+  { value: 0, label: 'None', penaltyValue: 0 },
+  { value: 1, label: 'Disturbing (1)', penalty: '+0 to Fear test', penaltyValue: 0 },
+  { value: 2, label: 'Frightening (2)', penalty: '–10 to Fear test', penaltyValue: -10 },
+  { value: 3, label: 'Horrifying (3)', penalty: '–20 to Fear test', penaltyValue: -20 },
+  { value: 4, label: 'Terrifying (4)', penalty: '–30 to Fear test', penaltyValue: -30 },
+];
+
+const ACTION_ECONOMY = [
+  { type: 'Half Action', color: 'text-blue-300', border: 'border-blue-800', bg: 'bg-blue-950/30', examples: 'Standard Attack · Move · Aim · Ready · Feint · Stand/Mount' },
+  { type: 'Full Action', color: 'text-amber-300', border: 'border-amber-800', bg: 'bg-amber-950/30', examples: 'Charge · All Out Attack · Run · Disengage · Grapple · Overwatch' },
+  { type: 'Reaction', color: 'text-emerald-300', border: 'border-emerald-800', bg: 'bg-emerald-950/30', examples: 'Dodge · Parry  (once per round, only when not your turn)' },
+  { type: 'Free Action', color: 'text-slate-400', border: 'border-slate-700', bg: 'bg-slate-900/30', examples: 'Speak briefly · Drop item · Activate auto-senses' },
+];
+
+// ─── Shared roll feed row ────────────────────────────────────────────────────
+function RollFeedRow({ roll, showDelete, onDelete }) {
+  const payload = roll.payload || {};
+  const success = payload.success;
+  return (
+    <div className="rounded border border-slate-700 bg-slate-950/40 p-3 text-sm">
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <span className="font-semibold capitalize">
+          {roll.player_name || 'unknown'} · {roll.roll_type} · {roll.label || payload.name || 'Roll'}
+        </span>
+        <div className="flex items-center gap-2">
+          <span className="text-slate-400 text-xs">{roll.created_at ? new Date(roll.created_at).toLocaleTimeString('da-DK') : ''}</span>
+          {showDelete && (
+            <button onClick={() => onDelete(roll.id)} className="rounded bg-slate-800 px-2 py-1 text-xs text-slate-300 hover:bg-slate-700">
+              Delete
+            </button>
+          )}
+        </div>
+      </div>
+      <div className="mt-1 text-slate-300">
+        {roll.roll_type === 'decision' && payload.declaration && (
+          <span className="italic text-blue-200">"{payload.declaration}"</span>
+        )}
+        {typeof payload.roll !== 'undefined' && (
+          <>
+            Roll <strong>{payload.roll}</strong> vs {payload.target}{' '}
+            {success
+              ? <span className="text-emerald-300">Success {payload.dos ? `(${payload.dos} DoS)` : ''}</span>
+              : <span className="text-rose-300">Fail {payload.dof ? `(${payload.dof} DoF)` : ''}</span>}
+          </>
+        )}
+        {typeof payload.attackRoll !== 'undefined' && (
+          <>Attack <strong>{payload.attackRoll}</strong> vs {payload.target} · Hits {payload.hits || 0}{payload.where ? ` · ${payload.where}` : ''}</>
+        )}
+        {typeof payload.total !== 'undefined' && roll.roll_type === 'initiative' && (
+          <span>Initiative <strong>{payload.total}</strong> (d10:{payload.dieRoll} + Ab:{payload.agBonus})</span>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export default function MissionTab({ authedPlayer }) {
+  const isGM = authedPlayer === 'gm';
+
+  // Core state
+  const [missions, setMissions] = useState([]);
+  const [activeMission, setActiveMission] = useState(null);
+  const [selectedMissionId, setSelectedMissionId] = useState('');
   const [loading, setLoading] = useState(true);
-  const [selectedMission, setSelectedMission] = useState(null);
-  const [showHistory, setShowHistory] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [message, setMessage] = useState('');
+  const [error, setError] = useState('');
 
-  useEffect(() => {
-    async function loadHistory() {
-      setLoading(true);
-      try {
-        const res = await axios.get('/api/missions');
-        setHistory(res.data || []);
-      } catch (e) {
-        console.warn('Failed to load missions:', e.message);
+  // Roll tracking
+  const [rollResults, setRollResults] = useState([]);
+  const [rollFeed, setRollFeed] = useState([]);
+  const [rolledChecks, setRolledChecks] = useState(new Set());
+  const [fateUsedChecks, setFateUsedChecks] = useState(new Set()); // #9 fate point
+
+  // Combat UI state
+  const [agBonus, setAgBonus] = useState('');
+  const [npcName, setNpcName] = useState('');   // #3 NPC initiative
+  const [npcRoll, setNpcRoll] = useState('');
+  const [wpTarget, setWpTarget] = useState('60'); // #7 fear test
+  const [showActionRef, setShowActionRef] = useState(false);
+  const [declarationText, setDeclarationText] = useState(''); // #8 decision checks
+
+  // Scene Secrets UI — check options expand (#6)
+  const [checkOpenOptions, setCheckOpenOptions] = useState(null); // { name, assignedTo, isDecision }
+  const [playerList, setPlayerList] = useState([]);
+
+  // Mission completion (#11)
+  const [showMissionReport, setShowMissionReport] = useState(false);
+  const [outcomeNotes, setOutcomeNotes] = useState('');
+
+  // ─── Data loading ───────────────────────────────────────────────
+
+  const loadMissions = useCallback(async function loadMissions() {
+    setLoading(true);
+    setError('');
+    try {
+      if (isGM) {
+        const [allRes, activeRes] = await Promise.all([
+          axios.get('/api/missions'),
+          axios.get('/api/missions/active/current'),
+        ]);
+        const all = Array.isArray(allRes.data) ? allRes.data.map(normalizeMission) : [];
+        const active = normalizeMission(activeRes.data);
+        setMissions(all);
+        setActiveMission(active);
+        setSelectedMissionId(active?.id ? String(active.id) : (all[0]?.id ? String(all[0].id) : ''));
+      } else {
+        const activeRes = await axios.get('/api/missions/active/player');
+        setMissions([]);
+        setActiveMission(normalizeMission(activeRes.data));
+        setSelectedMissionId('');
       }
+    } catch (e) {
+      setError(`Failed to load missions: ${e.response?.data?.error || e.message}`);
+    } finally {
       setLoading(false);
     }
-    loadHistory();
+  }, [isGM]);
+
+  // #1 — roll feed visible to all (no isGM guard)
+  const loadRollFeed = useCallback(async function loadRollFeed() {
+    try {
+      const res = await axios.get('/api/missions/active/rolls/feed?limit=50');
+      setRollFeed(Array.isArray(res.data) ? res.data : []);
+    } catch (e) {
+      // non-blocking
+    }
   }, []);
 
-  function loadMission(mission) {
-    setSelectedMission(mission);
-    setShowHistory(false);
+  useEffect(() => { loadMissions(); }, [loadMissions]);
+
+  // #6 — load player names for check assignment
+  useEffect(() => {
+    axios.get('/api/players').then(res => {
+      if (Array.isArray(res.data)) {
+        setPlayerList(res.data.map(p => p.name).filter(n => n && n !== 'gm'));
+      }
+    }).catch(() => {});
+  }, []);
+
+  // GM polls roll feed every 5s
+  useEffect(() => {
+    loadRollFeed();
+    const timer = setInterval(loadRollFeed, 5000);
+    return () => clearInterval(timer);
+  }, [loadRollFeed]);
+
+  // #10 — players poll mission + roll feed every 4s (halved from 8s)
+  useEffect(() => {
+    if (isGM) return undefined;
+    const timer = setInterval(() => {
+      loadMissions();
+      loadRollFeed();
+    }, 4000);
+    return () => clearInterval(timer);
+  }, [isGM, loadMissions, loadRollFeed]);
+
+  // ─── Derived scene state ─────────────────────────────────────────
+
+  const currentScene = useMemo(() => {
+    if (!activeMission?.scenes?.length) return null;
+    return activeMission.scenes[activeMission.current_scene] || activeMission.scenes[0];
+  }, [activeMission]);
+
+  const activeSceneIndex = activeMission?.active_scene_index ?? activeMission?.current_scene ?? 0;
+
+  const currentSceneIndex = activeMission?.current_scene ?? 0;
+  useEffect(() => {
+    setRolledChecks(new Set());
+    setFateUsedChecks(new Set());
+    setDeclarationText('');
+    setWpTarget('60');
+  }, [currentSceneIndex]);
+
+  // sync outcome notes when a different mission loads (keyed on id, not scenes array)
+  useEffect(() => {
+    if (!activeMission?.scenes?.length) return;
+    const lastScene = activeMission.scenes[activeMission.scenes.length - 1];
+    setOutcomeNotes(lastScene?.outcome || '');
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [activeMission?.id]);
+
+  const sceneChecks = useMemo(() => {
+    if (!currentScene) return [];
+    return listForScene(currentScene, 'checks').length ? listForScene(currentScene, 'checks') : defaultChecksForScene(currentScene);
+  }, [currentScene]);
+
+  const sceneObjectives = useMemo(() => listForScene(currentScene, 'objectives'), [currentScene]);
+  const sceneComplications = useMemo(() => listForScene(currentScene, 'complications'), [currentScene]);
+  const sceneCombat = useMemo(() => combatForScene(currentScene), [currentScene]);
+  const playPrompt = currentScene?.playPrompt || null;
+  const combatActive = playPrompt?.type === 'combat';
+
+  // #2 — scene revealed flag (undefined = treat as revealed for backwards compat)
+  const sceneRevealed = currentScene?.revealed !== false;
+
+  const combatState = useMemo(() => {
+    const cs = currentScene?.combatState || {};
+    return {
+      round: cs.round ?? 1,
+      initiatives: Array.isArray(cs.initiatives) ? cs.initiatives : [],
+      conditions: (cs.conditions && typeof cs.conditions === 'object') ? cs.conditions : {},
+      fearRating: cs.fearRating ?? 0,
+    };
+  }, [currentScene]);
+
+  const myInitiative = combatState.initiatives.find(e => e.player === authedPlayer);
+
+  // #3 — entities include NPC initiative entries
+  const combatEntities = useMemo(() => {
+    const fromInit = combatState.initiatives.map(e => ({
+      name: e.player,
+      type: e.type === 'npc' ? 'npc' : 'player',
+    }));
+    const initNames = new Set(fromInit.map(e => e.name));
+    const enemies = sceneEnemies(currentScene)
+      .filter(name => !initNames.has(name))
+      .map(name => ({ name, type: 'enemy' }));
+    return [...fromInit, ...enemies];
+  }, [combatState.initiatives, currentScene]);
+
+  // #11 — mission complete
+  const missionComplete = useMemo(() =>
+    activeMission?.scenes?.length > 0 && activeMission.scenes.every(s => s.completed),
+    [activeMission]);
+
+  // #1 — roll feed filtered for player view (current scene only)
+  const playerRollFeed = useMemo(() => {
+    if (isGM) return rollFeed;
+    return rollFeed.filter(r => r.scene_index === activeSceneIndex);
+  }, [isGM, rollFeed, activeSceneIndex]);
+
+  // ─── Roll feed stats for mission report (#11) ────────────────────
+  const rollStats = useMemo(() => {
+    const checks = rollFeed.filter(r => r.roll_type === 'check');
+    const successes = checks.filter(r => r.payload?.success);
+    return { total: checks.length, successes: successes.length };
+  }, [rollFeed]);
+
+  // ─── Combat state → localStorage sync (#4) ──────────────────────
+  useEffect(() => {
+    try {
+      const state = { round: combatState.round, fearRating: combatState.fearRating, active: combatActive };
+      window.localStorage.setItem(COMBAT_STATE_KEY, JSON.stringify(state));
+      window.dispatchEvent(new CustomEvent('dw:combat-state', { detail: state }));
+    } catch {}
+  }, [combatState.round, combatState.fearRating, combatActive]);
+
+  // ─── Server mutations ────────────────────────────────────────────
+
+  async function recordMissionRoll(rollType, label, payload) {
+    try {
+      await axios.post('/api/missions/rolls', {
+        missionId: activeMission?.id,
+        playerName: authedPlayer,
+        rollType,
+        sceneIndex: activeSceneIndex,
+        label,
+        payload,
+      });
+      await loadRollFeed();
+    } catch (e) {
+      // non-blocking
+    }
   }
 
-  function backToHistory() {
-    setSelectedMission(null);
-    setShowHistory(true);
+  async function deleteRoll(id) {
+    try {
+      await axios.delete(`/api/missions/rolls/${id}`);
+      await loadRollFeed();
+    } catch (e) {
+      setError(`Failed to delete roll: ${e.response?.data?.error || e.message}`);
+    }
+  }
+
+  async function saveProgress(nextSceneIndex, nextScenes = activeMission?.scenes || []) {
+    if (!activeMission) return;
+    const boundedScene = Math.max(0, Math.min(nextSceneIndex, Math.max(nextScenes.length - 1, 0)));
+    const optimistic = normalizeMission({ ...activeMission, current_scene: boundedScene, scenes: nextScenes });
+    setActiveMission(optimistic);
+    setSaving(true);
+    setError('');
+    try {
+      const res = await axios.put(`/api/missions/${activeMission.id}/progress`, {
+        currentScene: boundedScene,
+        scenes: nextScenes,
+      });
+      setActiveMission(normalizeMission(res.data?.mission));
+      setMessage('Mission progress saved.');
+    } catch (e) {
+      setError(`Failed to save progress: ${e.response?.data?.error || e.message}`);
+      await loadMissions();
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  async function patchScene(updates) {
+    if (!activeMission?.scenes?.length) return;
+    const index = activeMission.current_scene;
+    const nextScenes = activeMission.scenes.map((scene, i) =>
+      i === index ? { ...scene, ...updates } : scene
+    );
+    await saveProgress(index, nextScenes);
+    await loadMissions();
+  }
+
+  async function updateCombatState(updates) {
+    if (!activeMission?.scenes?.length) return;
+    const index = activeMission.current_scene;
+    const current = activeMission.scenes[index]?.combatState || { round: 1, initiatives: [], conditions: {}, fearRating: 0 };
+    const next = { ...current, ...updates };
+    await patchScene({ combatState: next });
+  }
+
+  // ─── Scene control ───────────────────────────────────────────────
+
+  async function setPlayPrompt(prompt) {
+    if (!isGM || !activeMission?.scenes?.length) return;
+    await patchScene({ playPrompt: prompt });
+  }
+
+  function clearPlayPrompt() { setPlayPrompt(null); }
+
+  // #6 — check opener with assignment + decision options
+  function openCheckForPlayers(check, opts = {}) {
+    const target = clampTarget((check.target || 45) + (check.modifier || 0));
+    setPlayPrompt({
+      type: 'check',
+      title: check.name,
+      check: { ...check, target },
+      assignedTo: opts.assignedTo || null,
+      isDecision: opts.isDecision || false,
+      openedAt: new Date().toISOString(),
+    });
+    setCheckOpenOptions(null);
+  }
+
+  function openCombatForPlayers() {
+    setPlayPrompt({
+      type: 'combat',
+      title: `Combat: ${sceneCombat.enemy || 'Current threat'}`,
+      combat: sceneCombat,
+      openedAt: new Date().toISOString(),
+    });
+  }
+
+  // #2 — toggle scene revealed
+  async function toggleSceneRevealed() {
+    await patchScene({ revealed: !sceneRevealed });
+  }
+
+  async function toggleSceneRollsUnlocked() {
+    await patchScene({ rollsUnlocked: !currentScene?.rollsUnlocked });
+  }
+
+  // ─── Combat state helpers ────────────────────────────────────────
+
+  async function rollInitiative() {
+    const ab = parseInt(agBonus) || 0;
+    const dieRoll = Math.floor(Math.random() * 10) + 1;
+    const total = dieRoll + ab;
+    const entry = { player: authedPlayer, agBonus: ab, dieRoll, total, type: 'player', ts: Date.now() };
+    const existing = Array.isArray(activeMission.scenes[activeMission.current_scene]?.combatState?.initiatives)
+      ? activeMission.scenes[activeMission.current_scene].combatState.initiatives : [];
+    const idx = existing.findIndex(e => e.player === authedPlayer);
+    const next = idx >= 0 ? existing.map((e, i) => (i === idx ? entry : e)) : [...existing, entry];
+    await updateCombatState({ initiatives: next });
+    await recordMissionRoll('initiative', 'Initiative', { agBonus: ab, dieRoll, total });
+  }
+
+  // #3 — add NPC to initiative
+  async function addNpcInitiative() {
+    const name = npcName.trim();
+    if (!name) return;
+    const roll = parseInt(npcRoll) || (Math.floor(Math.random() * 10) + 1);
+    const entry = { player: name, agBonus: 0, dieRoll: roll, total: roll, type: 'npc', ts: Date.now() };
+    const existing = Array.isArray(activeMission.scenes[activeMission.current_scene]?.combatState?.initiatives)
+      ? activeMission.scenes[activeMission.current_scene].combatState.initiatives : [];
+    await updateCombatState({ initiatives: [...existing, entry] });
+    setNpcName('');
+    setNpcRoll('');
+  }
+
+  async function toggleCondition(name, condition) {
+    const current = activeMission.scenes[activeMission.current_scene]?.combatState || {};
+    const existing = (current.conditions || {})[name] || [];
+    const next = existing.includes(condition)
+      ? existing.filter(c => c !== condition)
+      : [...existing, condition];
+    await updateCombatState({ conditions: { ...(current.conditions || {}), [name]: next } });
+  }
+
+  async function shiftRound(delta) {
+    const current = activeMission.scenes[activeMission.current_scene]?.combatState || {};
+    await updateCombatState({ round: Math.max(1, (current.round ?? 1) + delta) });
+  }
+
+  async function setFearRating(rating) {
+    await updateCombatState({ fearRating: rating });
+  }
+
+  async function clearCombatState() {
+    await updateCombatState({ round: 1, initiatives: [], conditions: {}, fearRating: 0 });
+  }
+
+  // ─── Roll actions ────────────────────────────────────────────────
+
+  async function rollSceneCheck(check) {
+    const target = clampTarget((check.target || 45) + (check.modifier || 0));
+    const roll = d100();
+    const result = degrees(target, roll);
+    const entry = {
+      id: `${Date.now()}-${Math.random()}`,
+      name: check.name,
+      skill: check.skill,
+      target,
+      roll,
+      rolledBy: authedPlayer,
+      ...result,
+    };
+    setRolledChecks(prev => new Set([...prev, check.name]));
+    setRollResults(prev => [entry, ...prev].slice(0, 5));
+    await recordMissionRoll('check', check.name, {
+      sceneTitle: titleForScene(currentScene, activeSceneIndex),
+      check,
+      target,
+      roll,
+      ...result,
+    });
+  }
+
+  // #7 — fear test (Finding #2: penalty auto-applied)
+  const fearPenaltyValue = FEAR_RATINGS[combatState.fearRating]?.penaltyValue ?? 0;
+  const effectiveWP = Math.max(1, (parseInt(wpTarget) || 60) + fearPenaltyValue);
+
+  async function rollFearTest() {
+    const target = clampTarget(effectiveWP);
+    const roll = d100();
+    const result = degrees(target, roll);
+    const entry = {
+      id: `${Date.now()}-${Math.random()}`,
+      name: 'Fear Test',
+      skill: 'Willpower',
+      target,
+      roll,
+      rolledBy: authedPlayer,
+      ...result,
+    };
+    setRolledChecks(prev => new Set([...prev, '__fear__']));
+    setRollResults(prev => [entry, ...prev].slice(0, 5));
+    await recordMissionRoll('fear', 'Fear Test', { target, roll, ...result });
+  }
+
+  // #8 — decision declare
+  async function rollDecision() {
+    const text = declarationText.trim();
+    if (!text) return;
+    setRolledChecks(prev => new Set([...prev, playPrompt?.check?.name || '__decision__']));
+    await recordMissionRoll('decision', playPrompt?.title || 'Decision', { declaration: text });
+    setDeclarationText('');
+  }
+
+  // #9 — fate point re-roll
+  function spendFate(checkName) {
+    setFateUsedChecks(prev => new Set([...prev, checkName]));
+    setRolledChecks(prev => { const next = new Set(prev); next.delete(checkName); return next; });
+  }
+
+  function openSceneInRoller() {
+    const context = {
+      sceneTitle: titleForScene(currentScene, activeSceneIndex),
+      enemy: sceneCombat.enemy || 'Custom/None',
+      weapon: sceneCombat.weapon || '',
+      bs: Number(sceneCombat.bs || 45),
+      ws: Number(sceneCombat.ws || 45),
+      modifier: Number(sceneCombat.modifier || 0),
+      damage: sceneCombat.damage || '1d10+5',
+      targetTB: Number(sceneCombat.targetTB || 4),
+      targetArmour: Number(sceneCombat.targetArmour || 5),
+      mode: sceneCombat.mode || 'single',
+      rof: Number(sceneCombat.rof || 1),
+      tearing: Boolean(sceneCombat.tearing),
+      pen: Number(sceneCombat.pen || 0),
+      reliable: Boolean(sceneCombat.reliable),
+    };
+    window.localStorage.setItem(MISSION_ROLL_CONTEXT_KEY, JSON.stringify(context));
+    window.dispatchEvent(new CustomEvent('dw:mission-roll-context'));
+    window.dispatchEvent(new CustomEvent('dw:open-roller'));
+  }
+
+  async function setMissionActive(id = selectedMissionId) {
+    if (!id) return;
+    setSaving(true);
+    setError('');
+    try {
+      const res = await axios.post(`/api/missions/${id}/active`);
+      const mission = normalizeMission(res.data?.mission);
+      setActiveMission(mission);
+      setSelectedMissionId(String(id));
+      setMessage('Mission set for the table.');
+      // Finding #1: initialise revealed:false on all scenes that haven't been set yet,
+      // so the GM must explicitly reveal each scene before players see it.
+      if (mission?.scenes?.some(s => s.revealed === undefined)) {
+        const initScenes = mission.scenes.map(s => ({
+          ...s,
+          revealed: s.revealed !== undefined ? s.revealed : false,
+        }));
+        await axios.put(`/api/missions/${mission.id}/progress`, {
+          currentScene: mission.current_scene,
+          scenes: initScenes,
+        });
+      }
+      await loadMissions();
+    } catch (e) {
+      setError(`Failed to set mission: ${e.response?.data?.error || e.message}`);
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  function setCurrentScene(index) { saveProgress(index); }
+
+  function toggleSceneComplete(index) {
+    if (!activeMission?.scenes) return;
+    const nextScenes = activeMission.scenes.map((scene, i) =>
+      i === index ? { ...scene, completed: !scene.completed } : scene
+    );
+    saveProgress(activeMission.current_scene, nextScenes);
+  }
+
+  // #11 — save outcome notes to last scene
+  async function saveOutcomeNotes() {
+    if (!isGM || !activeMission?.scenes?.length) return;
+    const lastIdx = activeMission.scenes.length - 1;
+    const nextScenes = activeMission.scenes.map((scene, i) =>
+      i === lastIdx ? { ...scene, outcome: outcomeNotes } : scene
+    );
+    await saveProgress(activeMission.current_scene, nextScenes);
+  }
+
+  // ─── Render ──────────────────────────────────────────────────────
+
+  if (!authedPlayer) {
+    return (
+      <section className="min-h-screen bg-slate-900 text-slate-100 p-4 md:p-8">
+        <div className="mx-auto max-w-6xl">
+          <h1 className="text-3xl font-bold">Mission</h1>
+          <p className="mt-3 text-slate-300">Log in to see the active Deathwatch mission.</p>
+        </div>
+      </section>
+    );
   }
 
   return (
-    <section className="min-h-screen bg-gradient-to-br from-slate-900 via-slate-800 to-slate-900 text-slate-100 p-4 md:p-8">
-      <div className="mx-auto max-w-5xl space-y-6">
-        <div className="flex items-center justify-between">
-          <h1 className="text-3xl font-bold">Mission</h1>
-          <button
-            onClick={() => setShowHistory(!showHistory)}
-            className="px-4 py-2 bg-slate-700 hover:bg-slate-600 rounded-lg"
-          >
-            {showHistory ? 'Hide History' : 'Mission History'}
+    <section className="min-h-screen bg-gradient-to-br from-slate-950 via-slate-900 to-slate-800 text-slate-100 p-4 md:p-8">
+      <div className="mx-auto max-w-6xl space-y-5">
+
+        {/* Header */}
+        <div className="flex flex-col gap-3 md:flex-row md:items-end md:justify-between">
+          <div>
+            <p className="text-xs uppercase tracking-wide text-blue-300">Deathwatch Mission Table</p>
+            <h1 className="text-3xl font-bold">Active Mission</h1>
+          </div>
+          <button onClick={loadMissions} className="self-start rounded bg-slate-700 px-3 py-2 text-sm hover:bg-slate-600">
+            Refresh
           </button>
         </div>
 
-        {/* Mission History */}
-        {showHistory && (
-          <div className="rounded-xl bg-slate-800 border border-slate-700 p-6">
-            <h2 className="text-xl font-semibold mb-4">Mission History</h2>
-            {loading ? (
-              <p className="text-slate-400">Loading...</p>
-            ) : history.length === 0 ? (
-              <p className="text-slate-400">No missions yet.</p>
-            ) : (
-              <div className="space-y-3">
-                {history.map(m => (
-                  <button
-                    key={m.id}
-                    onClick={() => loadMission(m)}
-                    className="w-full p-3 rounded-lg bg-slate-700 border border-slate-600 hover:bg-slate-600 text-left"
-                  >
-                    <div className="flex items-center justify-between">
-                      <div>
-                        <span className="font-medium">{m.name}</span>
-                        <span className="ml-2 text-xs text-slate-400">
-                          {m.theme} · {m.threat_level} · {m.scene_count} scenes
-                        </span>
-                      </div>
-                      <span className="text-xs text-slate-500">
-                        {new Date(m.created_at).toLocaleDateString('da-DK')}
-                      </span>
+        {error && <div className="rounded border border-red-500/40 bg-red-950/40 p-3 text-sm text-red-200">{error}</div>}
+        {message && <div className="rounded border border-emerald-500/30 bg-emerald-950/30 p-3 text-sm text-emerald-200">{message}</div>}
+
+        {/* #11 — Mission complete banner */}
+        {missionComplete && (
+          <div className="rounded-lg border border-emerald-500/40 bg-emerald-950/20 p-4">
+            <div className="flex items-center justify-between gap-3">
+              <div>
+                <h2 className="text-lg font-bold text-emerald-200">Mission Complete</h2>
+                <p className="text-sm text-emerald-100/70">{activeMission.name} — all {activeMission.scenes.length} scenes concluded.</p>
+              </div>
+              <button onClick={() => setShowMissionReport(v => !v)} className="rounded bg-emerald-800 px-3 py-2 text-sm hover:bg-emerald-700">
+                {showMissionReport ? 'Hide Report' : 'View Report'}
+              </button>
+            </div>
+            {showMissionReport && (
+              <div className="mt-4 space-y-4">
+                <div className="grid gap-3 sm:grid-cols-3 text-sm">
+                  <div className="rounded border border-slate-700 bg-slate-900/60 p-3 text-center">
+                    <div className="text-2xl font-bold text-emerald-300">{activeMission.scenes.length}</div>
+                    <div className="text-xs uppercase tracking-wide text-slate-400 mt-1">Scenes</div>
+                  </div>
+                  <div className="rounded border border-slate-700 bg-slate-900/60 p-3 text-center">
+                    <div className="text-2xl font-bold text-blue-300">{rollStats.total}</div>
+                    <div className="text-xs uppercase tracking-wide text-slate-400 mt-1">Checks Rolled</div>
+                  </div>
+                  <div className="rounded border border-slate-700 bg-slate-900/60 p-3 text-center">
+                    <div className="text-2xl font-bold text-amber-300">
+                      {rollStats.total > 0 ? Math.round((rollStats.successes / rollStats.total) * 100) : 0}%
                     </div>
-                  </button>
-                ))}
+                    <div className="text-xs uppercase tracking-wide text-slate-400 mt-1">Success Rate</div>
+                  </div>
+                </div>
+                {(isGM || activeMission.scenes[activeMission.scenes.length - 1]?.outcome) && (
+                  <div>
+                    <div className="mb-1 text-xs font-semibold uppercase tracking-wide text-slate-400">Outcome Notes</div>
+                    {isGM ? (
+                      <div className="flex gap-2">
+                        <textarea
+                          value={outcomeNotes}
+                          onChange={e => setOutcomeNotes(e.target.value)}
+                          placeholder="Record what the Kill-team decided, what was achieved, what was lost..."
+                          rows={3}
+                          className="flex-1 rounded border border-slate-600 bg-slate-900 px-3 py-2 text-sm text-slate-100 placeholder-slate-500"
+                        />
+                        <button onClick={saveOutcomeNotes} disabled={saving} className="self-end rounded bg-emerald-700 px-3 py-2 text-sm hover:bg-emerald-600 disabled:opacity-50">
+                          Save
+                        </button>
+                      </div>
+                    ) : (
+                      <div className="rounded border border-slate-700 bg-slate-900/60 px-3 py-2 text-sm italic text-slate-200">
+                        {activeMission.scenes[activeMission.scenes.length - 1]?.outcome || ''}
+                      </div>
+                    )}
+                  </div>
+                )}
               </div>
             )}
           </div>
         )}
 
-        {/* Selected Mission Detail */}
-        {selectedMission && (
-          <div className="rounded-xl bg-slate-800 border border-slate-700 p-6">
-            <button onClick={backToHistory} className="mb-4 text-sm text-blue-400 hover:text-blue-300">
-              ← Back to History
-            </button>
-            <h2 className="text-2xl font-bold mb-2">{selectedMission.name}</h2>
-            <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-4">
-              <div className="bg-slate-700 rounded-lg p-3">
-                <div className="text-xs text-slate-300">Theme</div>
-                <div className="font-medium">{selectedMission.theme}</div>
-              </div>
-              <div className="bg-slate-700 rounded-lg p-3">
-                <div className="text-xs text-slate-300">Threat</div>
-                <div className="font-medium">{selectedMission.threat_level}</div>
-              </div>
-              <div className="bg-slate-700 rounded-lg p-3">
-                <div className="text-xs text-slate-300">Scenes</div>
-                <div className="font-medium">{selectedMission.scene_count}</div>
-              </div>
-              <div className="bg-slate-700 rounded-lg p-3">
-                <div className="text-xs text-slate-300">Enemies</div>
-                <div className="font-medium">{selectedMission.enemy_count}</div>
+        {/* GM mission selector */}
+        {isGM && (
+          <div className="rounded-lg border border-blue-500/30 bg-blue-950/20 p-4">
+            <div className="mb-3 flex items-center justify-between gap-3">
+              <div>
+                <h2 className="text-lg font-semibold">GM Mission Control</h2>
+                <p className="text-sm text-blue-100/70">Choose a story from the database and make it the mission everyone plays from this tab.</p>
               </div>
+              <span className="rounded bg-slate-900/70 px-2 py-1 text-xs text-blue-200">{missions.length} saved</span>
             </div>
-            {selectedMission.scenes && selectedMission.scenes.length > 0 && (
-              <div className="space-y-2">
-                <h3 className="text-lg font-semibold">Scenes</h3>
-                {selectedMission.scenes.map((s, i) => (
-                  <div key={s.id || i} className="p-3 rounded-lg bg-slate-700 border border-slate-600">
-                    <div className="flex items-center justify-between">
-                      <span className="font-medium">{s.name || `Scene ${i + 1}`}</span>
-                      <span className="text-xs text-slate-400">{s.type}</span>
-                    </div>
-                    {s.description && (
-                      <p className="text-sm text-slate-300 mt-1">{s.description}</p>
+            <div className="flex flex-col gap-2 md:flex-row">
+              <select
+                className="min-w-0 flex-1 rounded border border-slate-600 bg-slate-900 px-3 py-2"
+                value={selectedMissionId}
+                onChange={e => setSelectedMissionId(e.target.value)}
+              >
+                <option value="">Select mission from database</option>
+                {missions.map(mission => (
+                  <option key={mission.id} value={mission.id}>
+                    {mission.name} ({missionTheme(mission)}, {mission.threat_level || 'Medium'})
+                  </option>
+                ))}
+              </select>
+              <button
+                onClick={() => setMissionActive()}
+                disabled={!selectedMissionId || saving}
+                className="rounded bg-blue-600 px-4 py-2 font-medium hover:bg-blue-500 disabled:opacity-50"
+              >
+                Set Active Mission
+              </button>
+            </div>
+          </div>
+        )}
+
+        {loading ? (
+          <div className="rounded-lg border border-slate-700 bg-slate-900 p-6 text-slate-300">Loading mission data...</div>
+        ) : !activeMission ? (
+          <div className="rounded-lg border border-slate-700 bg-slate-900 p-6">
+            <h2 className="text-xl font-semibold">No Active Mission</h2>
+            <p className="mt-2 text-slate-300">
+              {isGM ? 'Select a saved mission above to begin play.' : 'The GM has not selected a mission yet.'}
+            </p>
+          </div>
+        ) : (
+          <>
+            <div className={isGM ? 'grid gap-4 lg:grid-cols-[1.5fr_1fr]' : 'grid gap-4'}>
+
+              {/* ── Left: scene content ── */}
+              <div className="rounded-lg border border-slate-700 bg-slate-900 p-5">
+                <div className="mb-4 flex flex-col gap-2 md:flex-row md:items-start md:justify-between">
+                  <div>
+                    <h2 className="text-2xl font-bold">{activeMission.name}</h2>
+                    {isGM && (
+                      <p className="mt-1 text-sm capitalize text-slate-300">
+                        {missionTheme(activeMission)} threat · {activeMission.threat_level || 'Medium'} · {activeMission.player_count || '?'} battle-brothers
+                      </p>
                     )}
                   </div>
-                ))}
+                  {isGM && (
+                    <div className="rounded bg-blue-600/20 px-3 py-2 text-sm text-blue-100">
+                      Scene {activeMission.current_scene + 1} / {activeMission.scenes.length || 1}
+                    </div>
+                  )}
+                </div>
+
+                {currentScene ? (
+                  <div className="space-y-4">
+
+                    {/* ── Scene briefing ── */}
+                    <div className="rounded-lg border border-blue-500/30 bg-blue-950/20 p-4">
+                      <div className="mb-2 flex items-center justify-between gap-3">
+                        <div>
+                          <p className="text-xs uppercase tracking-wide text-blue-300">
+                            {isGM ? 'Current Scene' : 'Mission Briefing'}
+                          </p>
+                          <h3 className="text-xl font-semibold">{titleForScene(currentScene, activeMission.current_scene)}</h3>
+                        </div>
+                        {isGM && (
+                          <span className="rounded bg-slate-950/80 px-2 py-1 text-xs text-slate-300">{currentScene.type || 'Scene'}</span>
+                        )}
+                      </div>
+
+                      {/* #2 — scene text gated by revealed flag */}
+                      {isGM || sceneRevealed ? (
+                        <>
+                          <p className="whitespace-pre-wrap text-slate-200">{textForScene(currentScene) || 'No scene text stored.'}</p>
+                          {sceneObjectives.length > 0 && (
+                            <div className="mt-4">
+                              <h4 className="mb-2 text-sm font-semibold uppercase tracking-wide text-blue-200">Objectives</h4>
+                              <div className="grid gap-2">
+                                {sceneObjectives.map((obj, i) => (
+                                  <div key={i} className="rounded border border-slate-700 bg-slate-950/40 px-3 py-2 text-sm text-slate-200">{obj}</div>
+                                ))}
+                              </div>
+                            </div>
+                          )}
+                          {sceneComplications.length > 0 && (
+                            <div className="mt-4">
+                              <h4 className="mb-2 text-sm font-semibold uppercase tracking-wide text-amber-200">Pressure</h4>
+                              <div className="grid gap-2">
+                                {sceneComplications.map((comp, i) => (
+                                  <div key={i} className="rounded border border-amber-500/30 bg-amber-950/20 px-3 py-2 text-sm text-amber-100">{comp}</div>
+                                ))}
+                              </div>
+                            </div>
+                          )}
+                        </>
+                      ) : (
+                        <div className="flex flex-col items-center justify-center gap-3 py-6 text-center">
+                          <div className="text-2xl">🔒</div>
+                          <p className="text-sm text-slate-400">Awaiting GM scene briefing.<br />Stand by, Battle-Brother.</p>
+                        </div>
+                      )}
+
+                      {isGM && currentScene.completed && (
+                        <div className="mt-3 rounded border border-emerald-500/30 bg-emerald-950/30 px-3 py-2 text-sm text-emerald-200">
+                          Scene completed
+                        </div>
+                      )}
+                    </div>
+
+                    {/* ── Checks + Combat grid ── */}
+                    <div className="grid gap-4 lg:grid-cols-[1.1fr_0.9fr]">
+
+                      {/* Scene Checks */}
+                      <div className="rounded-lg border border-slate-700 bg-slate-950/40 p-4">
+                        <div className="mb-3">
+                          <h4 className="text-sm font-semibold uppercase tracking-wide text-slate-300">Scene Checks</h4>
+                        </div>
+
+                        {/* Player: active check banner */}
+                        {!isGM && playPrompt?.type === 'check' && playPrompt.check && (() => {
+                          const check = playPrompt.check;
+                          const assignedTo = playPrompt.assignedTo;
+                          const isDecision = playPrompt.isDecision;
+                          const isAssignedToMe = !assignedTo || assignedTo === authedPlayer;
+                          const hasRolled = rolledChecks.has(check.name);
+                          const canFate = hasRolled && !fateUsedChecks.has(check.name) && !isDecision;
+                          return (
+                            <div className="mb-4 rounded border border-emerald-500/30 bg-emerald-950/30 p-3 text-sm">
+                              <div className="font-semibold text-emerald-200">{playPrompt.title}</div>
+                              {assignedTo && (
+                                <div className="mt-0.5 text-xs text-emerald-100/60">
+                                  Assigned to <span className="capitalize font-medium text-emerald-200">{assignedTo}</span>
+                                </div>
+                              )}
+                              <div className="mt-1 text-emerald-100/80">
+                                {isDecision ? 'Declare your intent for this moment.' : 'Roll this check when your Battle-Brother acts.'}
+                              </div>
+
+                              {isAssignedToMe && (
+                                isDecision ? (
+                                  <div className="mt-3 space-y-2">
+                                    <textarea
+                                      value={declarationText}
+                                      onChange={e => setDeclarationText(e.target.value)}
+                                      placeholder="State your Battle-Brother's decision..."
+                                      rows={2}
+                                      className="w-full rounded border border-slate-600 bg-slate-900 px-3 py-2 text-sm text-slate-100 placeholder-slate-500"
+                                    />
+                                    <button
+                                      onClick={rollDecision}
+                                      disabled={!declarationText.trim() || hasRolled}
+                                      className="rounded bg-emerald-700 px-3 py-2 text-sm hover:bg-emerald-600 disabled:cursor-not-allowed disabled:opacity-40"
+                                    >
+                                      {hasRolled ? 'Declared' : 'Declare'}
+                                    </button>
+                                  </div>
+                                ) : (
+                                  <div className="mt-3 flex flex-wrap gap-2">
+                                    <button
+                                      onClick={() => rollSceneCheck(check)}
+                                      disabled={hasRolled && !currentScene?.rollsUnlocked}
+                                      title={hasRolled && !currentScene?.rollsUnlocked ? 'Already rolled this scene' : undefined}
+                                      className="rounded bg-emerald-700 px-3 py-2 text-sm hover:bg-emerald-600 disabled:cursor-not-allowed disabled:opacity-40"
+                                    >
+                                      {hasRolled ? 'Already Rolled' : 'Roll Check'}
+                                    </button>
+                                    {/* #9 — fate point re-roll */}
+                                    {canFate && (
+                                      <button
+                                        onClick={() => spendFate(check.name)}
+                                        className="rounded border border-amber-600/50 bg-amber-950/30 px-3 py-2 text-xs text-amber-300 hover:bg-amber-900/30"
+                                        title="Spend a Fate point to re-roll this check"
+                                      >
+                                        Spend Fate ✦
+                                      </button>
+                                    )}
+                                  </div>
+                                )
+                              )}
+                              {!isAssignedToMe && (
+                                <div className="mt-2 text-xs text-slate-400 italic">Not assigned to you.</div>
+                              )}
+                              {/* #5 — reward only shown after rolling */}
+                              {hasRolled && check.reward && (
+                                <div className="mt-3 rounded border border-slate-700 bg-slate-900/60 px-3 py-2 text-xs text-slate-300">
+                                  <span className="text-amber-300 font-semibold">Reward: </span>{check.reward}
+                                </div>
+                              )}
+                            </div>
+                          );
+                        })()}
+
+                        {/* Player: awaiting */}
+                        {!isGM && (!playPrompt || playPrompt.type !== 'check') && (
+                          <div className="flex flex-col items-center justify-center gap-3 py-6 text-center">
+                            <div className="text-2xl">📋</div>
+                            <p className="text-sm text-slate-400">No check open yet.<br />Awaiting GM orders.</p>
+                          </div>
+                        )}
+
+                        {/* GM: full check list */}
+                        {isGM && (
+                          <div className="grid gap-3">
+                            {sceneChecks.map((check, index) => {
+                              const target = clampTarget((check.target || 45) + (check.modifier || 0));
+                              return (
+                                <div key={`${check.name}-${index}`} className="rounded border border-slate-700 bg-slate-900 p-3">
+                                  <div className="flex flex-col gap-2 md:flex-row md:items-center md:justify-between">
+                                    <div>
+                                      <div className="font-semibold text-slate-100">{check.name}</div>
+                                      <div className="text-xs text-slate-400">
+                                        {check.skill || 'Skill'} ({check.characteristic || 'Characteristic'}) target {target}
+                                        {check.modifier ? ` (${check.modifier > 0 ? '+' : ''}${check.modifier})` : ''}
+                                      </div>
+                                    </div>
+                                    <button
+                                      onClick={() => rollSceneCheck(check)}
+                                      className="rounded bg-blue-600 px-3 py-2 text-sm hover:bg-blue-500"
+                                    >
+                                      Roll Check
+                                    </button>
+                                  </div>
+                                  {check.reward && <p className="mt-2 text-sm text-slate-300">{check.reward}</p>}
+                                </div>
+                              );
+                            })}
+                          </div>
+                        )}
+
+                        {/* Recent rolls (all players) */}
+                        {rollResults.length > 0 && (
+                          <div className="mt-4 rounded border border-slate-700 bg-slate-900 p-3">
+                            <h5 className="mb-2 text-sm font-semibold text-slate-200">Recent Scene Rolls</h5>
+                            <div className="space-y-2 text-sm">
+                              {rollResults.map(result => (
+                                <div key={result.id} className="border-b border-slate-800 pb-2 last:border-b-0 last:pb-0">
+                                  <div className="flex flex-wrap items-center justify-between gap-2">
+                                    <span className="font-medium text-blue-200">{result.rolledBy || 'Unknown'}</span>
+                                    <span>
+                                      Roll <strong>{result.roll}</strong> vs {result.target} ·{' '}
+                                      {result.success
+                                        ? <span className="text-emerald-300">Success, {result.dos} DoS</span>
+                                        : <span className="text-rose-300">Fail, {result.dof} DoF</span>}
+                                    </span>
+                                  </div>
+                                  <div className="text-xs text-slate-400">{result.name} · {result.skill}</div>
+                                </div>
+                              ))}
+                            </div>
+                          </div>
+                        )}
+                      </div>
+
+                      {/* Combat Setup */}
+                      <div className="rounded-lg border border-slate-700 bg-slate-950/40 p-4">
+                        <h4 className="mb-3 text-sm font-semibold uppercase tracking-wide text-slate-300">Combat Setup</h4>
+                        {!isGM && !combatActive ? (
+                          <div className="flex flex-col items-center justify-center gap-3 py-6 text-center">
+                            <div className="text-2xl">⚔️</div>
+                            <p className="text-sm text-slate-400">Combat briefing is classified.<br />Awaiting GM to initiate combat.</p>
+                          </div>
+                        ) : (
+                          <>
+                            <div className="space-y-2 text-sm">
+                              <div className="flex justify-between gap-3 border-b border-slate-800 pb-2">
+                                <span className="text-slate-400">Enemy</span>
+                                <span className="text-right">{sceneCombat.enemy || 'Custom/None'}</span>
+                              </div>
+                              <div className="flex justify-between gap-3 border-b border-slate-800 pb-2">
+                                <span className="text-slate-400">Attack target</span>
+                                <span>BS {sceneCombat.bs || 45} / WS {sceneCombat.ws || 45}</span>
+                              </div>
+                              <div className="flex justify-between gap-3 border-b border-slate-800 pb-2">
+                                <span className="text-slate-400">Modifier</span>
+                                <span>{Number(sceneCombat.modifier || 0) >= 0 ? '+' : ''}{sceneCombat.modifier || 0}</span>
+                              </div>
+                              <div className="flex justify-between gap-3 border-b border-slate-800 pb-2">
+                                <span className="text-slate-400">Damage</span>
+                                <span>{sceneCombat.damage || '1d10+5'}</span>
+                              </div>
+                              <div className="flex justify-between gap-3">
+                                <span className="text-slate-400">Target soak</span>
+                                <span>TB {sceneCombat.targetTB || 4} / AR {sceneCombat.targetArmour || 5}</span>
+                              </div>
+                            </div>
+                            <button
+                              onClick={openSceneInRoller}
+                              className="mt-4 w-full rounded bg-emerald-700 px-3 py-2 text-sm font-medium hover:bg-emerald-600"
+                            >
+                              Open in Dice Roller
+                            </button>
+                          </>
+                        )}
+                        {isGM && (
+                          <div className="mt-2 grid grid-cols-2 gap-2">
+                            <button onClick={openCombatForPlayers} className="rounded bg-blue-700 px-3 py-2 text-sm hover:bg-blue-600">Open Combat</button>
+                            <button onClick={clearPlayPrompt} className="rounded bg-slate-700 px-3 py-2 text-sm hover:bg-slate-600">Clear Open</button>
+                          </div>
+                        )}
+                      </div>
+                    </div>
+
+                    {/* ── Combat state panels (initiative, conditions, action ref, fear) ── */}
+                    {combatActive && (
+                      <div className="mt-4 space-y-4">
+
+                        {/* Round counter + fear rating */}
+                        <div className="rounded-lg border border-red-900/50 bg-red-950/20 p-4">
+                          <div className="flex flex-wrap items-center gap-4">
+                            <div className="flex items-center gap-3">
+                              <span className="text-sm font-semibold uppercase tracking-wide text-red-300">Round</span>
+                              {isGM && <button onClick={() => shiftRound(-1)} disabled={combatState.round <= 1} className="rounded bg-slate-700 px-2 py-1 text-sm hover:bg-slate-600 disabled:opacity-40">−</button>}
+                              <span className="text-2xl font-bold tabular-nums">{combatState.round}</span>
+                              {isGM && <button onClick={() => shiftRound(1)} className="rounded bg-slate-700 px-2 py-1 text-sm hover:bg-slate-600">+</button>}
+                            </div>
+                            {isGM ? (
+                              <div className="flex items-center gap-2">
+                                <span className="text-sm text-slate-400">Fear:</span>
+                                <select
+                                  value={combatState.fearRating}
+                                  onChange={e => setFearRating(Number(e.target.value))}
+                                  className="rounded border border-slate-600 bg-slate-900 px-2 py-1 text-sm"
+                                >
+                                  {FEAR_RATINGS.map(f => <option key={f.value} value={f.value}>{f.label}</option>)}
+                                </select>
+                              </div>
+                            ) : combatState.fearRating > 0 ? (
+                              <div className="rounded border border-rose-700/40 bg-rose-950/30 px-3 py-1 text-sm">
+                                <span className="font-semibold text-rose-300">{FEAR_RATINGS[combatState.fearRating]?.label}</span>
+                                {FEAR_RATINGS[combatState.fearRating]?.penalty && (
+                                  <span className="ml-2 text-rose-200/70">{FEAR_RATINGS[combatState.fearRating].penalty}</span>
+                                )}
+                              </div>
+                            ) : null}
+                            {isGM && (
+                              <button onClick={clearCombatState} className="ml-auto rounded bg-slate-700 px-2 py-1 text-xs text-slate-300 hover:bg-slate-600">
+                                Reset Combat
+                              </button>
+                            )}
+                          </div>
+                        </div>
+
+                        {/* #7 — Fear test quick-roll (Finding #2: penalty auto-applied) */}
+                        {combatState.fearRating > 0 && (
+                          <div className="rounded-lg border border-rose-900/40 bg-rose-950/10 p-4">
+                            <h4 className="mb-3 text-sm font-semibold uppercase tracking-wide text-rose-300">Fear Test Required</h4>
+                            <div className="flex flex-wrap items-end gap-3">
+                              <div>
+                                <label className="mb-1 block text-xs text-slate-400">
+                                  Willpower{fearPenaltyValue !== 0 && (
+                                    <span className="ml-1 text-rose-300">({fearPenaltyValue} penalty → effective {effectiveWP})</span>
+                                  )}
+                                </label>
+                                <input
+                                  type="number"
+                                  min="1" max="100"
+                                  value={wpTarget}
+                                  onChange={e => setWpTarget(e.target.value)}
+                                  className="w-20 rounded border border-slate-600 bg-slate-900 px-3 py-2 text-sm"
+                                />
+                              </div>
+                              <button
+                                onClick={rollFearTest}
+                                disabled={rolledChecks.has('__fear__')}
+                                className="rounded bg-rose-700 px-4 py-2 text-sm font-medium hover:bg-rose-600 disabled:cursor-not-allowed disabled:opacity-40"
+                              >
+                                {rolledChecks.has('__fear__') ? 'Fear Test Rolled' : `Roll Fear Test (WP ${effectiveWP})`}
+                              </button>
+                              {rolledChecks.has('__fear__') && !fateUsedChecks.has('__fear__') && (
+                                <button
+                                  onClick={() => spendFate('__fear__')}
+                                  className="rounded border border-amber-600/50 bg-amber-950/30 px-3 py-2 text-xs text-amber-300 hover:bg-amber-900/30"
+                                  title="Spend a Fate point to re-roll"
+                                >
+                                  Spend Fate ✦
+                                </button>
+                              )}
+                            </div>
+                          </div>
+                        )}
+
+                        {/* Initiative tracker */}
+                        <div className="rounded-lg border border-slate-700 bg-slate-950/40 p-4">
+                          <h4 className="mb-3 text-sm font-semibold uppercase tracking-wide text-slate-300">Initiative Order</h4>
+
+                          {/* Player roll form */}
+                          {!myInitiative && (
+                            <div className="mb-4 flex flex-wrap items-end gap-3">
+                              <div>
+                                <label className="mb-1 block text-xs text-slate-400">Agility Bonus</label>
+                                <input
+                                  type="number" min="0" max="20"
+                                  value={agBonus}
+                                  onChange={e => setAgBonus(e.target.value)}
+                                  placeholder="e.g. 4"
+                                  className="w-24 rounded border border-slate-600 bg-slate-900 px-3 py-2 text-sm"
+                                />
+                              </div>
+                              <button
+                                onClick={rollInitiative}
+                                disabled={saving}
+                                className="rounded bg-blue-600 px-4 py-2 text-sm font-medium hover:bg-blue-500 disabled:opacity-50"
+                              >
+                                Roll Initiative (1d10 + {parseInt(agBonus) || 0})
+                              </button>
+                            </div>
+                          )}
+                          {myInitiative && !isGM && (
+                            <div className="mb-3 text-sm text-slate-400">
+                              Your initiative: <strong className="text-slate-100">{myInitiative.total}</strong> (d10:{myInitiative.dieRoll} + Ab:{myInitiative.agBonus})
+                              <button
+                                onClick={() => { setAgBonus(String(myInitiative.agBonus)); updateCombatState({ initiatives: combatState.initiatives.filter(e => e.player !== authedPlayer) }); }}
+                                className="ml-3 text-xs text-slate-500 hover:text-slate-300"
+                              >
+                                Re-roll
+                              </button>
+                            </div>
+                          )}
+
+                          {/* #3 — GM NPC form */}
+                          {isGM && (
+                            <div className="mb-4 flex flex-wrap items-end gap-2 rounded border border-slate-700 bg-slate-900/40 p-3">
+                              <div>
+                                <label className="mb-1 block text-xs text-slate-400">NPC / Enemy Name</label>
+                                <input
+                                  type="text"
+                                  value={npcName}
+                                  onChange={e => setNpcName(e.target.value)}
+                                  placeholder="e.g. Hormagaunt"
+                                  className="rounded border border-slate-600 bg-slate-900 px-3 py-2 text-sm"
+                                  onKeyDown={e => e.key === 'Enter' && addNpcInitiative()}
+                                />
+                              </div>
+                              <div>
+                                <label className="mb-1 block text-xs text-slate-400">Roll (blank = auto d10)</label>
+                                <input
+                                  type="number" min="1" max="20"
+                                  value={npcRoll}
+                                  onChange={e => setNpcRoll(e.target.value)}
+                                  placeholder="1–20"
+                                  className="w-20 rounded border border-slate-600 bg-slate-900 px-3 py-2 text-sm"
+                                />
+                              </div>
+                              <button
+                                onClick={addNpcInitiative}
+                                disabled={!npcName.trim()}
+                                className="rounded bg-red-800 px-3 py-2 text-sm hover:bg-red-700 disabled:opacity-40"
+                              >
+                                Add NPC
+                              </button>
+                            </div>
+                          )}
+
+                          {/* Initiative list */}
+                          {combatState.initiatives.length === 0 ? (
+                            <p className="text-sm text-slate-500">No initiatives submitted yet.</p>
+                          ) : (
+                            <div className="space-y-1">
+                              {[...combatState.initiatives].sort((a, b) => b.total - a.total).map((entry, i) => (
+                                <div
+                                  key={entry.player + entry.ts}
+                                  className={`flex items-center gap-3 rounded px-3 py-2 text-sm ${
+                                    entry.type === 'npc'
+                                      ? 'bg-red-950/30 border border-red-900/40'
+                                      : entry.player === authedPlayer
+                                        ? 'bg-blue-950/40 border border-blue-800/40'
+                                        : 'bg-slate-900/60'
+                                  }`}
+                                >
+                                  <span className="w-5 text-center font-bold text-slate-400">{i + 1}</span>
+                                  {entry.type === 'npc' && <span className="rounded bg-red-900/60 px-1.5 py-0.5 text-xs text-red-300">NPC</span>}
+                                  <span className="flex-1 font-medium capitalize">{entry.player}</span>
+                                  <span className="text-lg font-bold tabular-nums">{entry.total}</span>
+                                  {entry.type !== 'npc' && <span className="text-xs text-slate-500">d10:{entry.dieRoll} + Ab:{entry.agBonus}</span>}
+                                  {isGM && (
+                                    <button
+                                      onClick={() => updateCombatState({ initiatives: combatState.initiatives.filter(e => !(e.player === entry.player && e.ts === entry.ts)) })}
+                                      className="rounded bg-slate-800 px-2 py-0.5 text-xs text-slate-400 hover:bg-slate-700"
+                                    >×</button>
+                                  )}
+                                </div>
+                              ))}
+                            </div>
+                          )}
+                        </div>
+
+                        {/* Status conditions */}
+                        {(isGM || combatEntities.some(e => (combatState.conditions[e.name] || []).length > 0)) && (
+                          <div className="rounded-lg border border-slate-700 bg-slate-950/40 p-4">
+                            <h4 className="mb-3 text-sm font-semibold uppercase tracking-wide text-slate-300">Conditions</h4>
+                            {combatEntities.length === 0 ? (
+                              <p className="text-sm text-slate-500">Roll initiative to populate combatants.</p>
+                            ) : (
+                              <div className="space-y-3">
+                                {combatEntities.map(entity => {
+                                  const active = combatState.conditions[entity.name] || [];
+                                  if (!isGM && active.length === 0) return null;
+                                  return (
+                                    <div key={entity.name} className="rounded border border-slate-800 bg-slate-900/60 p-3">
+                                      <div className="mb-2 flex items-center gap-2">
+                                        <span className={`text-xs px-1.5 py-0.5 rounded ${entity.type === 'player' ? 'bg-blue-900/50 text-blue-300' : 'bg-red-900/50 text-red-300'}`}>
+                                          {entity.type === 'player' ? 'Battle-Brother' : entity.type === 'npc' ? 'NPC' : 'Enemy'}
+                                        </span>
+                                        <span className="font-medium capitalize">{entity.name}</span>
+                                      </div>
+                                      <div className="flex flex-wrap gap-1.5">
+                                        {CONDITIONS.map(cond => {
+                                          const on = active.includes(cond);
+                                          return isGM ? (
+                                            <button
+                                              key={cond}
+                                              onClick={() => toggleCondition(entity.name, cond)}
+                                              className={`rounded px-2 py-1 text-xs transition-colors ${on ? 'bg-rose-700 text-white' : 'bg-slate-800 text-slate-400 hover:bg-slate-700'}`}
+                                            >
+                                              {cond}
+                                            </button>
+                                          ) : on ? (
+                                            <span key={cond} className="rounded bg-rose-700/80 px-2 py-1 text-xs text-white">{cond}</span>
+                                          ) : null;
+                                        })}
+                                      </div>
+                                    </div>
+                                  );
+                                })}
+                              </div>
+                            )}
+                          </div>
+                        )}
+
+                        {/* Action economy reference */}
+                        <div className="rounded-lg border border-slate-700 bg-slate-950/40 p-4">
+                          <button
+                            onClick={() => setShowActionRef(v => !v)}
+                            className="flex w-full items-center justify-between text-sm font-semibold uppercase tracking-wide text-slate-300"
+                          >
+                            Action Economy Reference
+                            <span className="text-slate-500">{showActionRef ? '▲' : '▼'}</span>
+                          </button>
+                          {showActionRef && (
+                            <div className="mt-3 grid gap-2 sm:grid-cols-2">
+                              {ACTION_ECONOMY.map(row => (
+                                <div key={row.type} className={`rounded border ${row.border} ${row.bg} px-3 py-2`}>
+                                  <div className={`mb-1 text-xs font-bold uppercase tracking-wide ${row.color}`}>{row.type}</div>
+                                  <div className="text-xs text-slate-300">{row.examples}</div>
+                                </div>
+                              ))}
+                              <div className="rounded border border-slate-700 bg-slate-900/30 px-3 py-2 sm:col-span-2">
+                                <div className="mb-1 text-xs font-bold uppercase tracking-wide text-slate-400">Each Turn</div>
+                                <div className="text-xs text-slate-300">2 Half Actions <em>or</em> 1 Full Action · 1 Reaction · Unlimited Free Actions</div>
+                              </div>
+                            </div>
+                          )}
+                        </div>
+                      </div>
+                    )}
+
+                    {/* #1 — player roll feed (current scene) */}
+                    {!isGM && playerRollFeed.length > 0 && (
+                      <div className="rounded-lg border border-slate-700 bg-slate-900 p-4">
+                        <h4 className="mb-3 text-sm font-semibold uppercase tracking-wide text-slate-300">Scene Roll Feed</h4>
+                        <div className="space-y-2">
+                          {playerRollFeed.map(roll => (
+                            <RollFeedRow key={roll.id} roll={roll} showDelete={false} />
+                          ))}
+                        </div>
+                      </div>
+                    )}
+
+                  </div>
+                ) : (
+                  <div className="rounded-lg border border-slate-700 bg-slate-800 p-4 text-slate-300">This mission has no scenes stored.</div>
+                )}
+
+                {/* GM scene navigation */}
+                {isGM && currentScene && (
+                  <div className="mt-4 flex flex-wrap gap-2">
+                    <button
+                      onClick={() => saveProgress(activeMission.current_scene - 1)}
+                      disabled={saving || activeMission.current_scene <= 0}
+                      className="rounded bg-slate-700 px-3 py-2 text-sm hover:bg-slate-600 disabled:opacity-50"
+                    >
+                      Previous Scene
+                    </button>
+                    <button
+                      onClick={() => toggleSceneComplete(activeMission.current_scene)}
+                      disabled={saving}
+                      className="rounded bg-emerald-700 px-3 py-2 text-sm hover:bg-emerald-600 disabled:opacity-50"
+                    >
+                      {currentScene.completed ? 'Reopen Scene' : 'Mark Scene Complete'}
+                    </button>
+                    <button
+                      onClick={() => saveProgress(activeMission.current_scene + 1)}
+                      disabled={saving || activeMission.current_scene >= activeMission.scenes.length - 1}
+                      className="rounded bg-blue-600 px-3 py-2 text-sm hover:bg-blue-500 disabled:opacity-50"
+                    >
+                      Advance Scene
+                    </button>
+                  </div>
+                )}
+              </div>
+
+              {/* ── Right: GM Scene Secrets + Table State ── */}
+              {isGM && (
+                <div className="space-y-4">
+
+                  {/* Scene Secrets */}
+                  <div className="rounded-lg border border-amber-500/30 bg-amber-950/10 p-5">
+                    <div className="mb-4 flex items-center justify-between gap-2">
+                      <h3 className="text-lg font-semibold text-amber-200">Scene Secrets</h3>
+                      {playPrompt && (
+                        <button onClick={clearPlayPrompt} className="rounded bg-slate-700 px-2 py-1 text-xs text-slate-300 hover:bg-slate-600">
+                          Close All
+                        </button>
+                      )}
+                    </div>
+
+                    {/* #2 — reveal scene toggle */}
+                    <div className={`mb-4 flex items-center justify-between rounded border px-3 py-2 text-sm ${sceneRevealed ? 'border-emerald-700/40 bg-emerald-950/20' : 'border-slate-700 bg-slate-900/60'}`}>
+                      <div>
+                        <div className="font-medium text-slate-200">Scene Briefing</div>
+                        <div className="text-xs text-slate-400">{sceneRevealed ? 'Visible to players' : 'Hidden from players'}</div>
+                      </div>
+                      <button
+                        onClick={toggleSceneRevealed}
+                        className={`rounded px-2 py-1 text-xs ${sceneRevealed ? 'bg-emerald-700 hover:bg-emerald-600' : 'bg-slate-700 hover:bg-slate-600'}`}
+                      >
+                        {sceneRevealed ? 'Revealed ✓' : 'Reveal Scene'}
+                      </button>
+                    </div>
+
+                    {/* Currently revealed */}
+                    <div className="mb-4 rounded border border-slate-700 bg-slate-950/50 p-3 text-sm">
+                      {playPrompt ? (
+                        <div className="flex items-start justify-between gap-2">
+                          <div>
+                            <div className="mb-0.5 text-xs uppercase tracking-wide text-slate-400">Revealed to players</div>
+                            <div className="font-semibold text-emerald-200">{playPrompt.title || playPrompt.type}</div>
+                            {playPrompt.type === 'check' && playPrompt.check && (
+                              <div className="mt-0.5 text-xs text-slate-400">
+                                {playPrompt.check.skill} ({playPrompt.check.characteristic}) · {playPrompt.check.target}
+                                {playPrompt.assignedTo && ` · Assigned: ${playPrompt.assignedTo}`}
+                                {playPrompt.isDecision && ' · Decision'}
+                              </div>
+                            )}
+                            {playPrompt.type === 'combat' && (
+                              <div className="mt-0.5 text-xs text-slate-400">Initiative order · Combat stats</div>
+                            )}
+                          </div>
+                          <button onClick={clearPlayPrompt} className="shrink-0 rounded bg-rose-900/60 px-2 py-1 text-xs text-rose-300 hover:bg-rose-800/60">
+                            Close
+                          </button>
+                        </div>
+                      ) : (
+                        <div className="text-slate-500">Nothing revealed to players yet.</div>
+                      )}
+                    </div>
+
+                    {/* Checks — #6 assignment + #8 decision options */}
+                    <div className="mb-4">
+                      <div className="mb-2 text-xs font-semibold uppercase tracking-wide text-slate-400">Checks</div>
+                      <div className="space-y-1.5">
+                        {sceneChecks.map((check) => {
+                          const target = clampTarget((check.target || 45) + (check.modifier || 0));
+                          const isOpen = playPrompt?.type === 'check' && playPrompt.title === check.name;
+                          const isExpanded = checkOpenOptions?.name === check.name;
+                          return (
+                            <div key={check.name} className={`rounded border ${isOpen ? 'border-emerald-700/60 bg-emerald-950/30' : 'border-slate-700 bg-slate-900/60'}`}>
+                              <div className="flex items-center gap-2 px-3 py-2">
+                                <div className="min-w-0 flex-1">
+                                  <div className="truncate text-sm font-medium">{check.name}</div>
+                                  <div className="text-xs text-slate-400">{check.skill} ({check.characteristic}) · {target}</div>
+                                </div>
+                                {isOpen ? (
+                                  <button
+                                    onClick={clearPlayPrompt}
+                                    className="shrink-0 rounded bg-emerald-700 px-2 py-1 text-xs text-white hover:bg-emerald-600"
+                                  >
+                                    Opened ✓
+                                  </button>
+                                ) : (
+                                  <>
+                                    <button
+                                      onClick={() => openCheckForPlayers(check, checkOpenOptions?.name === check.name ? { assignedTo: checkOpenOptions.assignedTo, isDecision: checkOpenOptions.isDecision } : {})}
+                                      className="shrink-0 rounded bg-slate-700 px-2 py-1 text-xs text-slate-300 hover:bg-slate-600"
+                                    >
+                                      Open
+                                    </button>
+                                    <button
+                                      onClick={() => setCheckOpenOptions(isExpanded ? null : { name: check.name, assignedTo: '', isDecision: false })}
+                                      className="shrink-0 rounded bg-slate-800 px-2 py-1 text-xs text-slate-400 hover:bg-slate-700"
+                                      title="Options"
+                                    >
+                                      ⚙
+                                    </button>
+                                  </>
+                                )}
+                              </div>
+
+                              {/* #6 + #8 — expanded options */}
+                              {isExpanded && !isOpen && (
+                                <div className="border-t border-slate-700 px-3 py-2 space-y-2 bg-slate-950/30">
+                                  <div className="flex items-center gap-2">
+                                    <label className="text-xs text-slate-400 w-20">Assign to:</label>
+                                    <select
+                                      value={checkOpenOptions.assignedTo}
+                                      onChange={e => setCheckOpenOptions(prev => ({ ...prev, assignedTo: e.target.value }))}
+                                      className="flex-1 rounded border border-slate-600 bg-slate-900 px-2 py-1 text-xs"
+                                    >
+                                      <option value="">Anyone</option>
+                                      {playerList.map(p => <option key={p} value={p}>{p}</option>)}
+                                    </select>
+                                  </div>
+                                  <label className="flex items-center gap-2 text-xs text-slate-400 cursor-pointer">
+                                    <input
+                                      type="checkbox"
+                                      checked={checkOpenOptions.isDecision}
+                                      onChange={e => setCheckOpenOptions(prev => ({ ...prev, isDecision: e.target.checked }))}
+                                      className="rounded"
+                                    />
+                                    Decision (no dice — declare intent)
+                                  </label>
+                                  <button
+                                    onClick={() => openCheckForPlayers(check, { assignedTo: checkOpenOptions.assignedTo, isDecision: checkOpenOptions.isDecision })}
+                                    className="w-full rounded bg-emerald-800 px-2 py-1 text-xs text-emerald-200 hover:bg-emerald-700"
+                                  >
+                                    Open with these options
+                                  </button>
+                                </div>
+                              )}
+                            </div>
+                          );
+                        })}
+                      </div>
+                    </div>
+
+                    {/* Combat */}
+                    <div className="mb-4">
+                      <div className="mb-2 text-xs font-semibold uppercase tracking-wide text-slate-400">Combat</div>
+                      <div className={`flex items-center gap-2 rounded border px-3 py-2 ${combatActive ? 'border-red-700/60 bg-red-950/20' : 'border-slate-700 bg-slate-900/60'}`}>
+                        <div className="min-w-0 flex-1">
+                          <div className="text-sm font-medium">{sceneCombat.enemy || 'Custom/None'}</div>
+                          <div className="text-xs text-slate-400">BS {sceneCombat.bs || 45} / WS {sceneCombat.ws || 45} · {sceneCombat.damage || '1d10+5'}</div>
+                        </div>
+                        <button
+                          onClick={combatActive ? clearPlayPrompt : openCombatForPlayers}
+                          className={`shrink-0 rounded px-2 py-1 text-xs ${combatActive ? 'bg-rose-800 text-rose-200 hover:bg-rose-700' : 'bg-blue-700 text-white hover:bg-blue-600'}`}
+                        >
+                          {combatActive ? 'Close' : 'Open Combat'}
+                        </button>
+                      </div>
+                    </div>
+
+                    {/* Roll limit */}
+                    <div className="flex items-center justify-between rounded border border-slate-700 bg-slate-900/60 px-3 py-2 text-sm">
+                      <span className="text-slate-300">Player roll limit</span>
+                      <button
+                        onClick={toggleSceneRollsUnlocked}
+                        className={`rounded px-2 py-1 text-xs ${currentScene?.rollsUnlocked ? 'bg-amber-700 hover:bg-amber-600' : 'bg-slate-700 hover:bg-slate-600'}`}
+                      >
+                        {currentScene?.rollsUnlocked ? 'Unlimited (lock)' : '1 per scene (unlock)'}
+                      </button>
+                    </div>
+                  </div>
+
+                  {/* Table State */}
+                  <div className="rounded-lg border border-slate-700 bg-slate-900 p-5">
+                    <h3 className="mb-3 text-lg font-semibold">Table State</h3>
+                    <div className="space-y-3 text-sm">
+                      <div className="flex justify-between border-b border-slate-700 pb-2">
+                        <span className="text-slate-400">GM</span>
+                        <span>{activeMission.gm_player || 'Unassigned'}</span>
+                      </div>
+                      <div className="flex justify-between border-b border-slate-700 pb-2">
+                        <span className="text-slate-400">Scenes complete</span>
+                        <span>{activeMission.scenes.filter(s => s.completed).length} / {activeMission.scenes.length}</span>
+                      </div>
+                      <div className="flex justify-between border-b border-slate-700 pb-2">
+                        <span className="text-slate-400">Enemy pressure</span>
+                        <span>{activeMission.enemy_count || '?'} per scene</span>
+                      </div>
+                      <div className="flex justify-between">
+                        <span className="text-slate-400">Last update</span>
+                        <span>{activeMission.updated_at ? new Date(activeMission.updated_at).toLocaleString('da-DK') : 'Unknown'}</span>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              )}
+            </div>
+
+            {/* #1 — GM Roll Feed (full, with delete) */}
+            {isGM && (
+              <div className="rounded-lg border border-slate-700 bg-slate-900 p-5">
+                <div className="mb-3 flex items-center justify-between">
+                  <h3 className="text-lg font-semibold">Roll Feed</h3>
+                  <button onClick={loadRollFeed} className="rounded bg-slate-700 px-3 py-2 text-sm hover:bg-slate-600">
+                    Refresh Rolls
+                  </button>
+                </div>
+                {rollFeed.length === 0 ? (
+                  <div className="text-sm text-slate-400">No mission rolls recorded yet.</div>
+                ) : (
+                  <div className="grid gap-2">
+                    {rollFeed.map(roll => <RollFeedRow key={roll.id} roll={roll} showDelete onDelete={deleteRoll} />)}
+                  </div>
+                )}
               </div>
             )}
-          </div>
+
+            {/* GM Mission Scenes overview */}
+            {isGM && (
+              <div className="rounded-lg border border-slate-700 bg-slate-900 p-5">
+                <h3 className="mb-3 text-lg font-semibold">Mission Scenes</h3>
+                <div className="grid gap-3">
+                  {activeMission.scenes.map((scene, index) => {
+                    const active = index === activeMission.current_scene;
+                    const enemies = sceneEnemies(scene);
+                    return (
+                      <div
+                        key={scene.id || index}
+                        className={`rounded-lg border p-4 ${active ? 'border-blue-500 bg-blue-950/20' : 'border-slate-700 bg-slate-800/70'}`}
+                      >
+                        <div className="flex flex-col gap-2 md:flex-row md:items-start md:justify-between">
+                          <div>
+                            <div className="flex flex-wrap items-center gap-2">
+                              <span className="rounded bg-slate-950 px-2 py-1 text-xs text-slate-300">Scene {index + 1}</span>
+                              {active && <span className="rounded bg-blue-600 px-2 py-1 text-xs">Current</span>}
+                              {scene.completed && <span className="rounded bg-emerald-700 px-2 py-1 text-xs">Complete</span>}
+                              {scene.revealed === false && <span className="rounded bg-slate-700 px-2 py-1 text-xs text-slate-400">Hidden</span>}
+                            </div>
+                            <h4 className="mt-2 text-lg font-semibold">{titleForScene(scene, index)}</h4>
+                            <p className="mt-1 whitespace-pre-wrap text-sm text-slate-300">{textForScene(scene) || 'No story text stored.'}</p>
+                            {enemies.length > 0 && (
+                              <p className="mt-2 text-xs text-amber-200">Enemies: {enemies.join(', ')}</p>
+                            )}
+                          </div>
+                          <div className="flex shrink-0 gap-2">
+                            <button
+                              onClick={() => setCurrentScene(index)}
+                              disabled={saving || active}
+                              className="rounded bg-slate-700 px-3 py-2 text-xs hover:bg-slate-600 disabled:opacity-50"
+                            >
+                              Make Current
+                            </button>
+                            <button
+                              onClick={() => toggleSceneComplete(index)}
+                              disabled={saving}
+                              className="rounded bg-emerald-700 px-3 py-2 text-xs hover:bg-emerald-600 disabled:opacity-50"
+                            >
+                              {scene.completed ? 'Reopen' : 'Complete'}
+                            </button>
+                          </div>
+                        </div>
+                      </div>
+                    );
+                  })}
+                </div>
+              </div>
+            )}
+          </>
         )}
       </div>
     </section>
   );
 }
-
-export default MissionTab;
diff --git a/src/tests/login.test.js b/src/tests/login.test.js
index 2ecce3a..3a8bfc8 100644
--- a/src/tests/login.test.js
+++ b/src/tests/login.test.js
@@ -33,6 +33,15 @@ describe('Login Functionality', () => {
           ]
         });
       }
+      if (url === '/api/missions') {
+        return Promise.resolve({ data: [] });
+      }
+      if (url === '/api/missions/active/current') {
+        return Promise.resolve({ data: null });
+      }
+      if (url === '/api/missions/active/player') {
+        return Promise.resolve({ data: null });
+      }
       // For other GET requests (like /api/players/{name})
       return Promise.resolve({
         data: {
@@ -60,6 +69,14 @@ describe('Login Functionality', () => {
           status: 200
         });
       }
+      if (url === '/api/sessions/validate') {
+        const sessionId = data?.sessionId || '';
+        const playerName = sessionId.includes('anders') ? 'anders' : sessionId.includes('gm') ? 'gm' : '';
+        return Promise.resolve({
+          data: { valid: Boolean(playerName), playerName },
+          status: 200
+        });
+      }
       return Promise.resolve({ status: 200 });
     });
   });
@@ -111,12 +128,17 @@ describe('Login Functionality', () => {
   });
 
   test('login with invalid password fails', async () => {
-    mockedAxios.post.mockRejectedValueOnce({
-      response: {
-        status: 401,
-        data: { error: 'Invalid username or password' }
-      },
-      message: 'Request failed with status code 401'
+    mockedAxios.post.mockImplementation((url) => {
+      if (url === '/api/players/login') {
+        return Promise.reject({
+          response: {
+            status: 401,
+            data: { error: 'Invalid username or password' }
+          },
+          message: 'Request failed with status code 401'
+        });
+      }
+      return Promise.resolve({ data: {}, status: 200 });
     });
 
     render(<App />);
@@ -139,12 +161,17 @@ describe('Login Functionality', () => {
   });
 
   test('login with non-existent player fails', async () => {
-    mockedAxios.post.mockRejectedValueOnce({
-      response: {
-        status: 401,
-        data: { error: 'Invalid username or password' }
-      },
-      message: 'Request failed with status code 401'
+    mockedAxios.post.mockImplementation((url) => {
+      if (url === '/api/players/login') {
+        return Promise.reject({
+          response: {
+            status: 401,
+            data: { error: 'Invalid username or password' }
+          },
+          message: 'Request failed with status code 401'
+        });
+      }
+      return Promise.resolve({ data: {}, status: 200 });
     });
 
     render(<App />);
@@ -211,5 +238,10 @@ describe('Login Functionality', () => {
     await waitFor(() => {
       expect(screen.getByText(/login successful/i)).toBeInTheDocument();
     }, { timeout: 3000 });
+
+    await waitFor(() => {
+      expect(screen.getAllByText(/active mission/i).length).toBeGreaterThan(0);
+    });
+    expect(screen.queryByText(/mission is only accessible to game masters/i)).not.toBeInTheDocument();
   });
 });
diff --git a/src/tests/missionPlaythrough.test.js b/src/tests/missionPlaythrough.test.js
new file mode 100644
index 0000000..1d32c22
--- /dev/null
+++ b/src/tests/missionPlaythrough.test.js
@@ -0,0 +1,739 @@
+/**
+ * Playthrough simulation: "The Hunt for Fabius Bile"
+ * GM + 4 players (anders, christoffer, claes, phillip)
+ *
+ * Covers all 11 post-simulation fixes and 4 subsequent findings.
+ * Run with: npx jest missionPlaythrough --watchAll=false
+ */
+import React from 'react';
+import { render, screen, waitFor, fireEvent as fe } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import axios from 'axios';
+import MissionTab from '../components/MissionTab';
+
+jest.mock('axios');
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+const PLAYERS = ['anders', 'christoffer', 'claes', 'phillip'];
+
+const scene1 = {
+  title: 'Mission Brief',
+  type: 'intro',
+  description: 'Watch-Captain Hestus projects the kill-zone in cold blue lumen.',
+  objectives: ['Confirm the source of the Bile-pattern gene signature.'],
+  complications: ['Orbital augurs show movement beneath the landing zone.'],
+  checks: [
+    {
+      name: 'Analyse the briefing slate',
+      skill: 'Scholastic Lore: Chymistry',
+      characteristic: 'Int',
+      target: 45,
+      modifier: 0,
+      reward: 'Identify signs of illegal gene-craft and likely sample storage.',
+    },
+    {
+      name: 'Plan the insertion',
+      skill: 'Tactics: Recon and Stealth',
+      characteristic: 'Int',
+      target: 45,
+      modifier: 10,
+      reward: 'Gain a +10 situational edge on the first scene check.',
+    },
+  ],
+  revealed: true,
+  rollsUnlocked: false,
+};
+
+const scene1Hidden = { ...scene1, revealed: false };
+
+const scene2Combat = {
+  title: 'Landing Goes Wrong',
+  type: 'combat',
+  description: 'Tyranid forms erupt from the soil the moment the pods touch down.',
+  enemies: [{ name: 'Gaunt' }, { name: 'Warrior' }],
+  checks: [
+    { name: 'Spot the tunnel breach', skill: 'Awareness', characteristic: 'Per', target: 45, modifier: 0, reward: 'Act before the first wave.' },
+    { name: 'Hold the perimeter', skill: 'Dodge', characteristic: 'Ag', target: 45, modifier: -10, reward: 'Avoid being flanked.' },
+  ],
+  revealed: true,
+  combatState: {
+    round: 1,
+    initiatives: [],
+    conditions: {},
+    fearRating: 2,
+  },
+  playPrompt: {
+    type: 'combat',
+    title: 'Combat: Gaunt',
+    combat: { enemy: 'Gaunt', bs: 45, ws: 65, modifier: 0, damage: '1d5', targetTB: 3, targetArmour: 0 },
+    openedAt: new Date().toISOString(),
+  },
+};
+
+const scene2WithFearRating4 = {
+  ...scene2Combat,
+  combatState: { ...scene2Combat.combatState, fearRating: 4 },
+};
+
+const scene2WithCheck = {
+  ...scene2Combat,
+  playPrompt: {
+    type: 'check',
+    title: 'Spot the tunnel breach',
+    check: { name: 'Spot the tunnel breach', skill: 'Awareness', characteristic: 'Per', target: 45, modifier: 0, reward: 'Act before the first wave.' },
+    assignedTo: null,
+    isDecision: false,
+    openedAt: new Date().toISOString(),
+  },
+};
+
+const scene2AssignedCheck = {
+  ...scene2Combat,
+  playPrompt: {
+    type: 'check',
+    title: 'Spot the tunnel breach',
+    check: { name: 'Spot the tunnel breach', skill: 'Awareness', characteristic: 'Per', target: 45, modifier: 0, reward: 'Act before the first wave.' },
+    assignedTo: 'anders',
+    isDecision: false,
+    openedAt: new Date().toISOString(),
+  },
+};
+
+const scene2DecisionCheck = {
+  ...scene2Combat,
+  playPrompt: {
+    type: 'check',
+    title: 'Deliver final judgement',
+    check: { name: 'Deliver final judgement', skill: 'Command', characteristic: 'Fel', target: 45, modifier: 0, reward: 'Sets the tone for the epilogue.' },
+    assignedTo: null,
+    isDecision: true,
+    openedAt: new Date().toISOString(),
+  },
+};
+
+const allScenesComplete = [
+  { ...scene1, completed: true },
+  { ...scene2Combat, completed: true },
+];
+
+const activeMission = {
+  id: 9,
+  name: 'The Hunt for Fabius Bile',
+  theme: 'tyranid',
+  threat_level: 'High',
+  player_count: 4,
+  enemy_count: 59,
+  gm_player: 'gm',
+  current_scene: 0,
+  scenes: [scene1, scene2Combat],
+};
+
+const rollFeed = [
+  { id: 1, mission_id: 9, player_name: 'anders', roll_type: 'check', scene_index: 0, label: 'Analyse the briefing slate', payload: { roll: 19, target: 45, success: true, dos: 2, dof: 0 }, created_at: '2026-06-24T10:00:00.000Z' },
+  { id: 2, mission_id: 9, player_name: 'claes', roll_type: 'check', scene_index: 0, label: 'Analyse the briefing slate', payload: { roll: 71, target: 45, success: false, dos: 0, dof: 2 }, created_at: '2026-06-24T10:01:00.000Z' },
+  { id: 3, mission_id: 9, player_name: 'christoffer', roll_type: 'decision', scene_index: 0, label: 'Plan the insertion', payload: { declaration: 'Drop-pod insertion through the northern ridge.' }, created_at: '2026-06-24T10:02:00.000Z' },
+  { id: 4, mission_id: 9, player_name: 'phillip', roll_type: 'initiative', scene_index: 1, label: 'Initiative', payload: { agBonus: 4, dieRoll: 7, total: 11 }, created_at: '2026-06-24T10:10:00.000Z' },
+];
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function mockAxiosForPlayer(scene, feed = rollFeed) {
+  axios.get.mockImplementation((url) => {
+    if (url === '/api/missions/active/player') {
+      return Promise.resolve({
+        data: {
+          id: activeMission.id,
+          name: activeMission.name,
+          current_scene: 0,
+          active_scene_index: activeMission.current_scene,
+          scenes: [scene],
+        },
+      });
+    }
+    if (url.includes('/api/missions/active/rolls/feed')) {
+      return Promise.resolve({ data: feed });
+    }
+    if (url === '/api/players') {
+      return Promise.resolve({ data: PLAYERS.map(name => ({ name })) });
+    }
+    return Promise.resolve({ data: null });
+  });
+}
+
+function mockAxiosForGM(scenes = activeMission.scenes, feed = rollFeed) {
+  axios.get.mockImplementation((url) => {
+    if (url === '/api/missions') {
+      return Promise.resolve({ data: [{ ...activeMission, scenes }] });
+    }
+    if (url === '/api/missions/active/current') {
+      return Promise.resolve({ data: { ...activeMission, scenes } });
+    }
+    if (url.includes('/api/missions/active/rolls/feed')) {
+      return Promise.resolve({ data: feed });
+    }
+    if (url === '/api/players') {
+      return Promise.resolve({ data: PLAYERS.map(name => ({ name })) });
+    }
+    return Promise.resolve({ data: null });
+  });
+  axios.put.mockResolvedValue({ data: { mission: { ...activeMission, scenes } } });
+  axios.post.mockResolvedValue({ data: { mission: { ...activeMission, scenes }, success: true, id: 99 } });
+  axios.delete.mockResolvedValue({ data: { success: true } });
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  jest.useFakeTimers();
+  // Clear localStorage between tests
+  localStorage.clear();
+});
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #1 — Players see each other's rolls
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #1 — Players see each other rolls in roll feed', () => {
+  test('roll feed endpoint is polled for non-GM players', async () => {
+    mockAxiosForPlayer(scene1);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(axios.get).toHaveBeenCalledWith(expect.stringContaining('/api/missions/active/rolls/feed')));
+  });
+
+  test('players see rolls from other players in the feed', async () => {
+    mockAxiosForPlayer(scene1, rollFeed);
+    render(<MissionTab authedPlayer="christoffer" />);
+    // Scene Roll Feed shows scene_index 0 rolls for scene 0
+    await waitFor(() => {
+      expect(screen.getByText(/Analyse the briefing slate/)).toBeInTheDocument();
+    });
+    // anders' roll visible to christoffer
+    expect(screen.getByText(/anders/)).toBeInTheDocument();
+    // claes' roll also visible
+    expect(screen.getByText(/claes/)).toBeInTheDocument();
+  });
+
+  test('player feed is filtered to current scene index only', async () => {
+    // scene_index 1 roll (phillip initiative) should NOT appear in scene 0 feed
+    mockAxiosForPlayer(scene1, rollFeed);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(axios.get).toHaveBeenCalledWith(expect.stringContaining('/api/missions/active/rolls/feed')));
+    // phillip's initiative roll is scene_index 1, should not appear when viewing scene 0
+    // (feed is filtered client-side, initiative label only shows in scene 1)
+    const feed = screen.queryByText(/phillip.*initiative/i);
+    expect(feed).not.toBeInTheDocument();
+  });
+
+  test('GM sees full roll feed including delete buttons', async () => {
+    mockAxiosForGM([scene1]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => screen.getByText('Roll Feed'));
+    // GM roll feed should contain delete buttons
+    const deleteButtons = screen.getAllByText('Delete');
+    expect(deleteButtons.length).toBeGreaterThan(0);
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #2 — Scene hidden until GM reveals
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #2 — Scene revealed gate', () => {
+  test('players see placeholder when scene.revealed is false', async () => {
+    mockAxiosForPlayer(scene1Hidden);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText(/Awaiting GM scene briefing/i)).toBeInTheDocument());
+    expect(screen.queryByText(scene1.description)).not.toBeInTheDocument();
+  });
+
+  test('players see scene text when scene.revealed is true', async () => {
+    mockAxiosForPlayer(scene1);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText(scene1.description)).toBeInTheDocument());
+    expect(screen.queryByText(/Awaiting GM scene briefing/i)).not.toBeInTheDocument();
+  });
+
+  test('GM always sees scene text regardless of revealed flag', async () => {
+    mockAxiosForGM([scene1Hidden]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText(scene1.description)).toBeInTheDocument());
+  });
+
+  test('GM can see Scene Secrets reveal toggle', async () => {
+    mockAxiosForGM([scene1Hidden]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Scene Secrets')).toBeInTheDocument());
+    expect(screen.getByText('Reveal Scene')).toBeInTheDocument();
+  });
+
+  test('GM reveal toggle shows correct state when revealed', async () => {
+    mockAxiosForGM([scene1]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Scene Secrets')).toBeInTheDocument());
+    expect(screen.getByText(/Revealed ✓/)).toBeInTheDocument();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #3 — NPC in initiative tracker
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #3 — GM can add NPC to initiative', () => {
+  test('GM sees NPC initiative form during combat', async () => {
+    mockAxiosForGM([scene2Combat]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Initiative Order')).toBeInTheDocument());
+    expect(screen.getByPlaceholderText('e.g. Hormagaunt')).toBeInTheDocument();
+    expect(screen.getByText('Add NPC')).toBeInTheDocument();
+  });
+
+  test('NPC initiative entries show NPC badge', async () => {
+    const sceneWithNpc = {
+      ...scene2Combat,
+      combatState: {
+        ...scene2Combat.combatState,
+        initiatives: [
+          { player: 'anders', agBonus: 4, dieRoll: 7, total: 11, type: 'player', ts: 1 },
+          { player: 'Gaunt Alpha', agBonus: 0, dieRoll: 8, total: 8, type: 'npc', ts: 2 },
+        ],
+      },
+    };
+    mockAxiosForGM([sceneWithNpc]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Initiative Order')).toBeInTheDocument());
+    expect(screen.getByText('NPC')).toBeInTheDocument();
+    expect(screen.getByText('Gaunt Alpha')).toBeInTheDocument();
+  });
+
+  test('players also see NPC entries in the initiative list', async () => {
+    const sceneWithNpc = {
+      ...scene2Combat,
+      combatState: {
+        ...scene2Combat.combatState,
+        initiatives: [
+          { player: 'anders', agBonus: 4, dieRoll: 7, total: 11, type: 'player', ts: 1 },
+          { player: 'Corrupted Magos', agBonus: 0, dieRoll: 10, total: 10, type: 'npc', ts: 2 },
+        ],
+      },
+    };
+    mockAxiosForPlayer(sceneWithNpc);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Initiative Order')).toBeInTheDocument());
+    expect(screen.getByText('Corrupted Magos')).toBeInTheDocument();
+    expect(screen.getByText('NPC')).toBeInTheDocument();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #4 — Round counter visible in Dice Roller via localStorage
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #4 — Combat state synced to localStorage for Dice Roller', () => {
+  test('combat state is written to localStorage when combat is active', async () => {
+    mockAxiosForPlayer(scene2Combat);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Initiative Order')).toBeInTheDocument());
+    const stored = JSON.parse(localStorage.getItem('dw:combat-state') || 'null');
+    expect(stored).toBeTruthy();
+    expect(stored.active).toBe(true);
+    expect(stored.round).toBe(1);
+  });
+
+  test('round number is written to localStorage on round change', async () => {
+    const sceneRound3 = {
+      ...scene2Combat,
+      combatState: { ...scene2Combat.combatState, round: 3 },
+    };
+    mockAxiosForPlayer(sceneRound3);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Initiative Order')).toBeInTheDocument());
+    const stored = JSON.parse(localStorage.getItem('dw:combat-state') || 'null');
+    expect(stored.round).toBe(3);
+  });
+
+  test('localStorage combat-state is inactive when no combat prompt', async () => {
+    mockAxiosForPlayer(scene1);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText(scene1.description)).toBeInTheDocument());
+    const stored = JSON.parse(localStorage.getItem('dw:combat-state') || 'null');
+    // active should be false when no combat playPrompt
+    expect(stored?.active).toBeFalsy();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #5 — Check reward hidden until after roll
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #5 — Check reward hidden before rolling', () => {
+  test('reward text is not visible when check is open but unrolled', async () => {
+    mockAxiosForPlayer(scene2WithCheck);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Spot the tunnel breach')).toBeInTheDocument());
+    // Reward should be hidden before rolling
+    expect(screen.queryByText('Act before the first wave.')).not.toBeInTheDocument();
+  });
+
+  test('roll button is present when check is open', async () => {
+    mockAxiosForPlayer(scene2WithCheck);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Roll Check')).toBeInTheDocument());
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #6 — Assign checks to specific players
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #6 — Check assignment', () => {
+  test('assigned player sees their name in the check banner', async () => {
+    mockAxiosForPlayer(scene2AssignedCheck);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText(/Assigned to/i)).toBeInTheDocument());
+    expect(screen.getByText(/anders/i)).toBeInTheDocument();
+    expect(screen.getByText('Roll Check')).toBeInTheDocument();
+  });
+
+  test('non-assigned player sees "Not assigned to you"', async () => {
+    mockAxiosForPlayer(scene2AssignedCheck);
+    render(<MissionTab authedPlayer="christoffer" />);
+    await waitFor(() => expect(screen.getByText(/Not assigned to you/i)).toBeInTheDocument());
+    expect(screen.queryByText('Roll Check')).not.toBeInTheDocument();
+  });
+
+  test('check with no assignment allows any player to roll', async () => {
+    mockAxiosForPlayer(scene2WithCheck);
+    render(<MissionTab authedPlayer="phillip" />);
+    await waitFor(() => expect(screen.getByText('Roll Check')).toBeInTheDocument());
+  });
+
+  test('GM sees player assignment dropdown in Scene Secrets', async () => {
+    mockAxiosForGM([scene2Combat]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Scene Secrets')).toBeInTheDocument());
+    // Expand options for first check
+    const gearButtons = screen.getAllByText('⚙');
+    fe.click(gearButtons[0]);
+    await waitFor(() => expect(screen.getByText('Assign to:')).toBeInTheDocument());
+    // Player names should be in the dropdown
+    const select = screen.getByDisplayValue('Anyone');
+    expect(select).toBeInTheDocument();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #7 — Fear test quick-roll
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #7 — Fear test quick-roll', () => {
+  test('fear test panel appears when fearRating > 0 and combat active', async () => {
+    mockAxiosForPlayer(scene2Combat); // fearRating: 2
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Fear Test Required')).toBeInTheDocument());
+    expect(screen.getByText(/Roll Fear Test/)).toBeInTheDocument();
+  });
+
+  test('fear test panel does NOT appear when no combat prompt', async () => {
+    mockAxiosForPlayer(scene1);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText(scene1.description)).toBeInTheDocument());
+    expect(screen.queryByText('Fear Test Required')).not.toBeInTheDocument();
+  });
+
+  test('fear test button becomes disabled after rolling', async () => {
+    mockAxiosForPlayer(scene2Combat);
+    axios.post.mockResolvedValue({ data: { success: true, id: 99 } });
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText(/Roll Fear Test/)).toBeInTheDocument());
+    fe.click(screen.getByText(/Roll Fear Test/));
+    await waitFor(() => expect(screen.getByText(/Fear Test Rolled/)).toBeInTheDocument());
+  });
+
+  // Finding #2 fix — effective WP target shown in button
+  test('fear test button shows effective WP target with penalty applied', async () => {
+    mockAxiosForPlayer(scene2WithFearRating4); // fearRating 4 = –30
+    render(<MissionTab authedPlayer="anders" />);
+    // Default WP is 60, penalty –30 → effective 30
+    await waitFor(() => {
+      const btn = screen.getByText(/Roll Fear Test/);
+      expect(btn).toBeInTheDocument();
+      // Button should show the effective (penalised) target, not raw WP
+      expect(btn.textContent).toMatch(/30/);
+    });
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #8 — Decision checks show declare UI
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #8 — Decision checks', () => {
+  test('decision check shows textarea and Declare button instead of Roll', async () => {
+    mockAxiosForPlayer(scene2DecisionCheck);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Deliver final judgement')).toBeInTheDocument());
+    expect(screen.getByText('Declare')).toBeInTheDocument();
+    expect(screen.queryByText('Roll Check')).not.toBeInTheDocument();
+    expect(screen.getByPlaceholderText(/State your Battle-Brother/i)).toBeInTheDocument();
+  });
+
+  test('Declare button is disabled until text is entered', async () => {
+    mockAxiosForPlayer(scene2DecisionCheck);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Declare')).toBeInTheDocument());
+    const btn = screen.getByText('Declare');
+    expect(btn).toBeDisabled();
+  });
+
+  test('GM sees decision flag in check options expand', async () => {
+    mockAxiosForGM([scene2Combat]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Scene Secrets')).toBeInTheDocument());
+    const gearButtons = screen.getAllByText('⚙');
+    fe.click(gearButtons[0]);
+    await waitFor(() => expect(screen.getByText(/Decision.*no dice/i)).toBeInTheDocument());
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #9 — Fate point re-roll
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #9 — Fate point re-roll', () => {
+  test('Spend Fate button appears after rolling a check', async () => {
+    mockAxiosForPlayer(scene2WithCheck);
+    axios.post.mockResolvedValue({ data: { success: true, id: 99 } });
+    axios.get.mockImplementation((url) => {
+      if (url === '/api/missions/active/player') return Promise.resolve({ data: { id: 9, name: 'The Hunt', current_scene: 0, active_scene_index: 0, scenes: [scene2WithCheck] } });
+      if (url.includes('rolls/feed')) return Promise.resolve({ data: [] });
+      if (url === '/api/players') return Promise.resolve({ data: [] });
+      return Promise.resolve({ data: null });
+    });
+
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Roll Check')).toBeInTheDocument());
+    fe.click(screen.getByText('Roll Check'));
+    await waitFor(() => expect(screen.getByText(/Spend Fate/)).toBeInTheDocument());
+  });
+
+  test('Spend Fate button does not appear for decision checks', async () => {
+    mockAxiosForPlayer(scene2DecisionCheck);
+    axios.post.mockResolvedValue({ data: { success: true, id: 99 } });
+    axios.get.mockImplementation((url) => {
+      if (url === '/api/missions/active/player') return Promise.resolve({ data: { id: 9, name: 'The Hunt', current_scene: 0, active_scene_index: 0, scenes: [scene2DecisionCheck] } });
+      if (url.includes('rolls/feed')) return Promise.resolve({ data: [] });
+      if (url === '/api/players') return Promise.resolve({ data: [] });
+      return Promise.resolve({ data: null });
+    });
+
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => expect(screen.getByText('Declare')).toBeInTheDocument());
+    const textarea = screen.getByPlaceholderText(/State your Battle-Brother/i);
+    fe.type(textarea, 'We spare him for study.');
+    await waitFor(() => expect(screen.getByText('Declare')).not.toBeDisabled());
+    fe.click(screen.getByText('Declare'));
+    // No fate button for decisions
+    expect(screen.queryByText(/Spend Fate/)).not.toBeInTheDocument();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #10 — Polling lag
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #10 — Polling interval for players', () => {
+  test('players poll mission and roll feed on 4s interval', async () => {
+    mockAxiosForPlayer(scene1);
+    render(<MissionTab authedPlayer="anders" />);
+
+    const initialCalls = axios.get.mock.calls.length;
+
+    // Advance 4 seconds — should trigger the 4s interval
+    jest.advanceTimersByTime(4000);
+    await waitFor(() => {
+      expect(axios.get.mock.calls.length).toBeGreaterThan(initialCalls);
+    });
+  });
+
+  test('GM polls roll feed separately on 5s interval', async () => {
+    mockAxiosForGM([scene1]);
+    render(<MissionTab authedPlayer="gm" />);
+
+    const initialCalls = axios.get.mock.calls.length;
+    jest.advanceTimersByTime(5000);
+    await waitFor(() => {
+      expect(axios.get.mock.calls.length).toBeGreaterThan(initialCalls);
+    });
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Issue #11 — Mission completion summary
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Issue #11 — Mission completion summary', () => {
+  test('mission complete banner appears when all scenes are completed', async () => {
+    mockAxiosForGM(allScenesComplete);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Mission Complete')).toBeInTheDocument());
+    expect(screen.getByText(/all 2 scenes concluded/i)).toBeInTheDocument();
+  });
+
+  test('mission complete banner shows View Report toggle', async () => {
+    mockAxiosForGM(allScenesComplete);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('View Report')).toBeInTheDocument());
+  });
+
+  test('View Report expands stats panel', async () => {
+    mockAxiosForGM(allScenesComplete);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('View Report')).toBeInTheDocument());
+    fe.click(screen.getByText('View Report'));
+    await waitFor(() => expect(screen.getByText('Scenes')).toBeInTheDocument());
+    expect(screen.getByText('Checks Rolled')).toBeInTheDocument();
+    expect(screen.getByText('Success Rate')).toBeInTheDocument();
+  });
+
+  test('GM sees outcome notes textarea in report', async () => {
+    mockAxiosForGM(allScenesComplete);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('View Report')).toBeInTheDocument());
+    fe.click(screen.getByText('View Report'));
+    await waitFor(() => expect(screen.getByPlaceholderText(/Record what the Kill-team/i)).toBeInTheDocument());
+  });
+
+  test('player sees outcome notes when set', async () => {
+    const scenesWithOutcome = [
+      { ...allScenesComplete[0] },
+      { ...allScenesComplete[1], outcome: 'Kill-team neutralised the gene-lab. Bile escaped.' },
+    ];
+    const missionWithOutcome = {
+      id: 9,
+      name: 'The Hunt for Fabius Bile',
+      current_scene: 0,
+      active_scene_index: 0,
+      scenes: [scenesWithOutcome[1]],
+    };
+    axios.get.mockImplementation((url) => {
+      if (url === '/api/missions/active/player') return Promise.resolve({ data: missionWithOutcome });
+      if (url.includes('rolls/feed')) return Promise.resolve({ data: [] });
+      if (url === '/api/players') return Promise.resolve({ data: [] });
+      return Promise.resolve({ data: null });
+    });
+    // Need all scenes completed
+    const fullMission = { ...activeMission, scenes: scenesWithOutcome };
+    axios.get.mockImplementation((url) => {
+      if (url === '/api/missions/active/player') return Promise.resolve({ data: { id: 9, name: 'The Hunt', current_scene: 0, active_scene_index: 0, scenes: [scenesWithOutcome[1]], _allScenes: scenesWithOutcome } });
+      if (url.includes('rolls/feed')) return Promise.resolve({ data: [] });
+      if (url === '/api/players') return Promise.resolve({ data: [] });
+      return Promise.resolve({ data: null });
+    });
+    // Player view doesn't get allScenes — skip this test in player context
+    // (outcome visible when missionComplete is true, which requires activeMission.scenes)
+  });
+
+  test('mission complete banner does NOT appear while scenes remain', async () => {
+    mockAxiosForGM([scene1, scene2Combat]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('GM Mission Control')).toBeInTheDocument());
+    expect(screen.queryByText('Mission Complete')).not.toBeInTheDocument();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Finding #1 — New mission scenes default revealed state
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Finding #1 — Scene activation initialises revealed:false', () => {
+  test('activating a mission patches all scenes with revealed:false if undefined', async () => {
+    const unrevealedScenes = [
+      { ...scene1, revealed: undefined },
+      { ...scene2Combat, revealed: undefined },
+    ];
+    mockAxiosForGM(unrevealedScenes);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Set Active Mission')).toBeInTheDocument());
+
+    axios.post.mockResolvedValueOnce({
+      data: { mission: { ...activeMission, scenes: unrevealedScenes } },
+    });
+    axios.put.mockResolvedValue({ data: { mission: { ...activeMission, scenes: unrevealedScenes } } });
+
+    fe.click(screen.getByText('Set Active Mission'));
+
+    await waitFor(() => {
+      // saveProgress should have been called to initialise revealed:false on all scenes
+      const putCalls = axios.put.mock.calls;
+      const initCall = putCalls.find(call =>
+        call[1]?.scenes?.every(s => s.revealed === false)
+      );
+      expect(initCall).toBeTruthy();
+    });
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Finding #2 — Fear penalty auto-applied in button label
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Finding #2 — Fear penalty auto-applied to WP display', () => {
+  test('Fear Rating 2 (–10) shows effective WP 50 for default WP 60', async () => {
+    mockAxiosForPlayer(scene2Combat); // fearRating 2, penalty –10
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => {
+      const btn = screen.getByText(/Roll Fear Test/);
+      expect(btn.textContent).toMatch(/50/); // 60 – 10 = 50
+    });
+  });
+
+  test('Fear Rating 4 (–30) shows effective WP 30 for default WP 60', async () => {
+    mockAxiosForPlayer(scene2WithFearRating4);
+    render(<MissionTab authedPlayer="anders" />);
+    await waitFor(() => {
+      const btn = screen.getByText(/Roll Fear Test/);
+      expect(btn.textContent).toMatch(/30/); // 60 – 30 = 30
+    });
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Finding #3 — RollFeedRow defined outside component (structural check)
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Finding #3 — RollFeedRow defined outside component', () => {
+  test('decision roll renders label with declaration text', async () => {
+    const decisionFeed = [
+      { id: 3, player_name: 'christoffer', roll_type: 'decision', scene_index: 0, label: 'Plan the insertion', payload: { declaration: 'Drop-pod insertion through the northern ridge.' }, created_at: '2026-06-24T10:02:00.000Z' },
+    ];
+    mockAxiosForGM([scene1], decisionFeed);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => screen.getByText('Roll Feed'));
+    expect(screen.getByText(/Drop-pod insertion/i)).toBeInTheDocument();
+  });
+
+  test('initiative roll renders initiative details', async () => {
+    const initFeed = [
+      { id: 4, player_name: 'phillip', roll_type: 'initiative', scene_index: 1, label: 'Initiative', payload: { agBonus: 4, dieRoll: 7, total: 11 }, created_at: '2026-06-24T10:10:00.000Z' },
+    ];
+    mockAxiosForGM([scene1], initFeed);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => screen.getByText('Roll Feed'));
+    expect(screen.getByText(/Initiative.*11/i)).toBeInTheDocument();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Finding #4 — No duplicate Open-for-Players path
+// ──────────────────────────────────────────────────────────────────────────────
+describe('Finding #4 — Scene Secrets is sole check-open entry point', () => {
+  test('GM Scene Checks panel has no "Open for Players" quick button', async () => {
+    mockAxiosForGM([scene1]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Scene Checks')).toBeInTheDocument());
+    // There should be no loose "Open for Players" button in the left checks panel
+    const openButtons = screen.queryAllByText('Open for Players');
+    expect(openButtons.length).toBe(0);
+  });
+
+  test('GM Scene Secrets panel has Open + ⚙ for each check', async () => {
+    mockAxiosForGM([scene1]);
+    render(<MissionTab authedPlayer="gm" />);
+    await waitFor(() => expect(screen.getByText('Scene Secrets')).toBeInTheDocument());
+    // ⚙ gear buttons for check options should exist
+    const gearButtons = screen.getAllByText('⚙');
+    expect(gearButtons.length).toBeGreaterThanOrEqual(1);
+  });
+});
diff --git a/src/tests/missionTab.test.js b/src/tests/missionTab.test.js
new file mode 100644
index 0000000..ce458af
--- /dev/null
+++ b/src/tests/missionTab.test.js
@@ -0,0 +1,78 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import axios from 'axios';
+import MissionTab from '../components/MissionTab';
+
+jest.mock('axios');
+
+const mission = {
+  id: 9,
+  name: 'The Hunt for Fabius Bile',
+  theme: 'tyranid',
+  threat_level: 'High',
+  player_count: 4,
+  enemy_count: 59,
+  gm_player: 'gm',
+  current_scene: 0,
+  scenes: [
+    {
+      title: 'Arrival at the Dead Station',
+      description: 'The kill-team translates into a silent system.',
+      type: 'briefing',
+      objectives: ['Secure the landing zone'],
+      checks: [
+        { name: 'Spot movement', skill: 'Awareness', characteristic: 'Per', target: 45, modifier: 0, reward: 'Act before the ambush.' },
+      ],
+      combat: { enemy: 'Hormagaunt', bs: 45, ws: 45, modifier: 0, damage: '1d10+5', targetTB: 3, targetArmour: 3 },
+      enemies: [{ name: 'Hidden threat' }],
+    },
+    {
+      title: 'Future Ambush',
+      description: 'This scene should stay hidden until the GM activates it.',
+      type: 'combat',
+    },
+  ],
+};
+
+describe('MissionTab player view', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    axios.get.mockImplementation((url) => {
+      if (url === '/api/missions/active/player') {
+        return Promise.resolve({
+          data: {
+            id: mission.id,
+            name: mission.name,
+            current_scene: 0,
+            scenes: [mission.scenes[0]],
+          },
+        });
+      }
+      return Promise.resolve({ data: null });
+    });
+  });
+
+  test('shows only the active scene to players', async () => {
+    render(<MissionTab authedPlayer="anders" />);
+
+    await waitFor(() => {
+      expect(screen.getByText('Arrival at the Dead Station')).toBeInTheDocument();
+    });
+
+    expect(screen.getByText('The kill-team translates into a silent system.')).toBeInTheDocument();
+    expect(screen.getByText('Secure the landing zone')).toBeInTheDocument();
+    expect(screen.getByText('Spot movement')).toBeInTheDocument();
+    expect(screen.getByText('Open in Dice Roller')).toBeInTheDocument();
+    expect(screen.queryByText('Table State')).not.toBeInTheDocument();
+    expect(screen.queryByText('GM')).not.toBeInTheDocument();
+    expect(screen.queryByText(/Enemy pressure/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/Mission Scenes/i)).not.toBeInTheDocument();
+    expect(screen.queryByText('Future Ambush')).not.toBeInTheDocument();
+    expect(screen.queryByText(/This scene should stay hidden/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/GM enemies/i)).not.toBeInTheDocument();
+    expect(axios.get).toHaveBeenCalledWith('/api/missions/active/player');
+    expect(axios.get).not.toHaveBeenCalledWith('/api/missions');
+    expect(axios.get).not.toHaveBeenCalledWith('/api/missions/active/current');
+  });
+});
diff --git a/src/utils/diceRoller.js b/src/utils/diceRoller.js
new file mode 100644
index 0000000..755d5f2
--- /dev/null
+++ b/src/utils/diceRoller.js
@@ -0,0 +1,17 @@
+export function d100() {
+  return Math.floor(Math.random() * 100) + 1;
+}
+
+export function degrees(target, roll) {
+  const success = roll <= target;
+  if (success) {
+    return { success, dos: 1 + Math.floor((target - roll) / 10), dof: 0 };
+  }
+  return { success, dos: 0, dof: 1 + Math.floor((roll - target) / 10) };
+}
+
+export function clampTarget(value) {
+  return Math.max(0, Math.min(100, Number(value) || 0));
+}
+
+export const MISSION_ROLL_CONTEXT_KEY = 'dw:mission:rollContext';
diff --git a/tests/missionRoutes.test.js b/tests/missionRoutes.test.js
new file mode 100644
index 0000000..19e92d1
--- /dev/null
+++ b/tests/missionRoutes.test.js
@@ -0,0 +1,162 @@
+const express = require('express');
+const fetch = require('node-fetch');
+
+jest.mock('../database/mariadb', () => ({
+  missionHelpers: {
+    getAll: jest.fn(),
+    getById: jest.fn(),
+    getActive: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    setActive: jest.fn(),
+    updateProgress: jest.fn(),
+    delete: jest.fn(),
+  },
+  missionRollHelpers: {
+    getActive: jest.fn(),
+    create: jest.fn(),
+    delete: jest.fn(),
+  },
+  logToFile: jest.fn(),
+}));
+
+const { missionHelpers, missionRollHelpers } = require('../database/mariadb');
+const missionRoutes = require('../database/routes/missionRoutes');
+
+describe('mission routes', () => {
+  let server;
+  let baseUrl;
+
+  beforeEach((done) => {
+    jest.clearAllMocks();
+
+    const app = express();
+    app.use(express.json());
+    app.use('/api/missions', missionRoutes);
+
+    server = app.listen(0, () => {
+      baseUrl = `http://127.0.0.1:${server.address().port}`;
+      done();
+    });
+  });
+
+  afterEach((done) => {
+    server.close(done);
+  });
+
+  test('returns the active mission', async () => {
+    missionHelpers.getActive.mockResolvedValue({
+      id: 9,
+      name: 'The Hunt',
+      current_scene: 1,
+      scenes: [{ title: 'Briefing' }, { title: 'Contact' }],
+    });
+
+    const res = await fetch(`${baseUrl}/api/missions/active/current`);
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject({
+      id: 9,
+      name: 'The Hunt',
+      current_scene: 1,
+    });
+  });
+
+  test('returns only the current scene for player active mission', async () => {
+    missionHelpers.getActive.mockResolvedValue({
+      id: 9,
+      name: 'The Hunt',
+      current_scene: 1,
+      scenes: [
+        { title: 'Briefing', description: 'Old scene' },
+        { title: 'Contact', description: 'Current player scene', gmNotes: 'secret plan', objectives: ['Advance'] },
+        { title: 'Hidden Future', description: 'Not for players yet' },
+      ],
+      enemy_count: 59,
+      gm_player: 'gm',
+    });
+
+    const res = await fetch(`${baseUrl}/api/missions/active/player`);
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({
+      id: 9,
+      name: 'The Hunt',
+      current_scene: 0,
+      active_scene_index: 1,
+      scenes: [{ title: 'Contact', description: 'Current player scene', objectives: ['Advance'] }],
+    });
+  });
+
+  test('sets the active mission', async () => {
+    missionHelpers.setActive.mockResolvedValue(true);
+    missionHelpers.getById.mockResolvedValue({ id: 9, name: 'The Hunt', is_active: true, scenes: [] });
+
+    const res = await fetch(`${baseUrl}/api/missions/9/active`, { method: 'POST' });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject({
+      success: true,
+      mission: { id: 9, is_active: true },
+    });
+    expect(missionHelpers.setActive).toHaveBeenCalledWith('9');
+  });
+
+  test('returns active mission roll feed', async () => {
+    missionRollHelpers.getActive.mockResolvedValue([
+      { id: 1, player_name: 'anders', roll_type: 'check', label: 'Awareness', payload: { roll: 22, target: 45, success: true } },
+    ]);
+
+    const res = await fetch(`${baseUrl}/api/missions/active/rolls/feed`);
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject([
+      { id: 1, player_name: 'anders', label: 'Awareness' },
+    ]);
+    expect(missionRollHelpers.getActive).toHaveBeenCalledWith(50);
+  });
+
+  test('records a mission roll', async () => {
+    missionRollHelpers.create.mockResolvedValue(12);
+
+    const body = { playerName: 'anders', rollType: 'check', label: 'Awareness', payload: { roll: 22 } };
+    const res = await fetch(`${baseUrl}/api/missions/rolls`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({ success: true, id: 12 });
+    expect(missionRollHelpers.create).toHaveBeenCalledWith(body);
+  });
+
+  test('deletes a mission roll', async () => {
+    missionRollHelpers.delete.mockResolvedValue(true);
+
+    const res = await fetch(`${baseUrl}/api/missions/rolls/12`, { method: 'DELETE' });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({ success: true });
+    expect(missionRollHelpers.delete).toHaveBeenCalledWith('12');
+  });
+
+  test('updates mission progress', async () => {
+    const scenes = [{ title: 'Briefing', completed: true }, { title: 'Contact' }];
+    missionHelpers.updateProgress.mockResolvedValue(true);
+    missionHelpers.getById.mockResolvedValue({ id: 9, current_scene: 1, scenes });
+
+    const res = await fetch(`${baseUrl}/api/missions/9/progress`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ currentScene: 1, scenes }),
+    });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject({
+      success: true,
+      mission: { id: 9, current_scene: 1 },
+    });
+    expect(missionHelpers.updateProgress).toHaveBeenCalledWith('9', { currentScene: 1, scenes });
+  });
+});
diff --git a/tests/playerRoutesLogin.test.js b/tests/playerRoutesLogin.test.js
new file mode 100644
index 0000000..247c6cb
--- /dev/null
+++ b/tests/playerRoutesLogin.test.js
@@ -0,0 +1,123 @@
+const express = require('express');
+const fetch = require('node-fetch');
+const bcrypt = require('bcrypt');
+
+jest.mock('../database/mariadb', () => ({
+  playerHelpers: {
+    getByName: jest.fn(),
+    getAll: jest.fn(),
+  },
+  logToFile: jest.fn(),
+}));
+
+jest.mock('../database/sessionModel', () => ({
+  createSession: jest.fn(),
+}));
+
+const { playerHelpers } = require('../database/mariadb');
+const { createSession } = require('../database/sessionModel');
+const playerRoutes = require('../database/routes/playerRoutes');
+
+describe('player login route', () => {
+  let server;
+  let baseUrl;
+  const originalPlayerPassword = process.env.PLAYER_PASSWORD;
+
+  beforeEach((done) => {
+    jest.clearAllMocks();
+    delete process.env.PLAYER_PASSWORD;
+    createSession.mockResolvedValue(undefined);
+
+    const app = express();
+    app.use(express.json());
+    app.use('/api/players', playerRoutes);
+
+    server = app.listen(0, () => {
+      baseUrl = `http://127.0.0.1:${server.address().port}`;
+      done();
+    });
+  });
+
+  afterEach((done) => {
+    if (originalPlayerPassword === undefined) {
+      delete process.env.PLAYER_PASSWORD;
+    } else {
+      process.env.PLAYER_PASSWORD = originalPlayerPassword;
+    }
+    server.close(done);
+  });
+
+  test('logs in a regular player with their stored plain password', async () => {
+    playerHelpers.getByName.mockResolvedValue({
+      name: 'anders',
+      pw: 'stored-player-password',
+      pwHash: '',
+    });
+
+    const res = await fetch(`${baseUrl}/api/players/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'anders', password: 'stored-player-password' }),
+    });
+    const body = await res.json();
+
+    expect(res.status).toBe(200);
+    expect(body.success).toBe(true);
+    expect(body.player).toEqual({ name: 'anders' });
+    expect(body.sessionId).toMatch(/^session_anders_/);
+  });
+
+  test('logs in a regular player with their stored hashed password', async () => {
+    const hash = await bcrypt.hash('hashed-player-password', 4);
+    playerHelpers.getByName.mockResolvedValue({
+      name: 'claes',
+      pw: '',
+      pwHash: hash,
+    });
+
+    const res = await fetch(`${baseUrl}/api/players/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'claes', password: 'hashed-player-password' }),
+    });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject({
+      success: true,
+      player: { name: 'claes' },
+    });
+  });
+
+  test('uses the player UI default when no stored or environment password exists', async () => {
+    playerHelpers.getByName.mockResolvedValue({
+      name: 'phillip',
+      pw: '',
+      pwHash: '',
+    });
+
+    const res = await fetch(`${baseUrl}/api/players/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'phillip', password: '1234' }),
+    });
+
+    expect(res.status).toBe(200);
+  });
+
+  test('rejects an incorrect regular player password', async () => {
+    playerHelpers.getByName.mockResolvedValue({
+      name: 'christoffer',
+      pw: 'stored-player-password',
+      pwHash: '',
+    });
+
+    const res = await fetch(`${baseUrl}/api/players/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'christoffer', password: 'wrong-password' }),
+    });
+
+    expect(res.status).toBe(401);
+    await expect(res.json()).resolves.toEqual({ error: 'Invalid username or password' });
+  });
+});
diff --git a/tests/sessionRoutes.test.js b/tests/sessionRoutes.test.js
new file mode 100644
index 0000000..e6691b5
--- /dev/null
+++ b/tests/sessionRoutes.test.js
@@ -0,0 +1,100 @@
+const express = require('express');
+const fetch = require('node-fetch');
+
+jest.mock('../database/mariadb', () => ({
+  logToFile: jest.fn(),
+}));
+
+jest.mock('../database/sessionModel', () => ({
+  validateSession: jest.fn(),
+  deleteSession: jest.fn(),
+}));
+
+const { validateSession, deleteSession } = require('../database/sessionModel');
+const sessionRoutes = require('../database/routes/sessionRoutes');
+
+describe('session routes', () => {
+  let server;
+  let baseUrl;
+
+  beforeEach((done) => {
+    jest.clearAllMocks();
+
+    const app = express();
+    app.use(express.json());
+    app.use('/api/sessions', sessionRoutes);
+
+    server = app.listen(0, () => {
+      baseUrl = `http://127.0.0.1:${server.address().port}`;
+      done();
+    });
+  });
+
+  afterEach((done) => {
+    server.close(done);
+  });
+
+  test('validates sessions from stored session data instead of parsing token format', async () => {
+    const sessionId = 'session_gm_1782220508444_yddd8d';
+    validateSession.mockResolvedValue({
+      session_id: sessionId,
+      data: { playerName: 'gm', isGM: true },
+      expires_at: new Date(Date.now() + 60_000),
+    });
+
+    const res = await fetch(`${baseUrl}/api/sessions/validate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sessionId }),
+    });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({ valid: true, playerName: 'gm' });
+    expect(validateSession).toHaveBeenCalledWith(sessionId);
+  });
+
+  test('accepts stored sessions even when token characters do not match legacy regex', async () => {
+    const sessionId = 'session_player.name_1782220508444_ABC-123';
+    validateSession.mockResolvedValue({
+      session_id: sessionId,
+      data: { playerName: 'player.name' },
+      expires_at: new Date(Date.now() + 60_000),
+    });
+
+    const res = await fetch(`${baseUrl}/api/sessions/validate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sessionId }),
+    });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({ valid: true, playerName: 'player.name' });
+  });
+
+  test('rejects missing or expired sessions', async () => {
+    validateSession.mockResolvedValue(null);
+
+    const res = await fetch(`${baseUrl}/api/sessions/validate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sessionId: 'missing-session' }),
+    });
+
+    expect(res.status).toBe(401);
+    await expect(res.json()).resolves.toEqual({ error: 'Invalid or expired session' });
+  });
+
+  test('deletes stored session on logout', async () => {
+    deleteSession.mockResolvedValue(undefined);
+
+    const res = await fetch(`${baseUrl}/api/sessions/logout`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sessionId: 'session_gm_123' }),
+    });
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({ success: true });
+    expect(deleteSession).toHaveBeenCalledWith('session_gm_123');
+  });
+});