diff --git a/backend/src/routes/tests.js b/backend/src/routes/tests.js
index dd2f53e..dcf785b 100644
--- a/backend/src/routes/tests.js
+++ b/backend/src/routes/tests.js
@@ -9,6 +9,28 @@ import pool, { query } from '../db/db.js';
 import { authenticate } from '../middleware/auth.js';
 import { hasAnyAttemptForTest } from '../services/testChainService.js';
 import { saveTestDraft, createTestWithVersion } from '../services/testDraftService.js';
+import {
+  getEditorContent,
+  getPlayContent,
+  submitAttempt,
+  getAttemptReviewForUser,
+  listTestAttemptsForAuthor,
+} from '../services/testAttemptService.js';
+import { extractTextFromFile } from '../services/documentExtractService.js';
+import { generationForImportDocument } from '../services/documentGenService.js';
+import { RU } from '../messages/ru.js';
+import { isTestAuthor } from '../config/devAuthor.js';
+import { ensureClinicUserIdForStaff } from '../services/assignmentUserService.js';
+import {
+  queryTestsVisibleToUser,
+  userHasTestAccess,
+} from '../services/testAccessService.js';
+import { isAssignmentFeatureEnabled } from '../config/featureFlags.js';
+import {
+  generateFullTestByShape,
+  generateOrRephraseQuestion,
+  parseAndValidateShape,
+} from '../services/aiEditorService.js';
 
 const router = express.Router();
 const upload = multer({
@@ -28,35 +50,59 @@ function asyncHandler(fn) {
   };
 }
 
-/** D.1 — раньше /:id, иначе id = "import" */
+/** D.1 + D.2 + D.3 (заглушка) — `POST` до маршрутов `/:id` */
 router.post(
   '/import/document',
   authenticate,
-  upload.single('file'),
+  (req, res, next) => {
+    upload.single('file')(req, res, (err) => {
+      if (err) {
+        if (err.code === 'LIMIT_FILE_SIZE') {
+          return res.status(413).json({ error: RU.fileTooLarge });
+        }
+        return next(err);
+      }
+      next();
+    });
+  },
   asyncHandler(async (req, res) => {
     if (!req.file) {
-      return res.status(400).json({ error: 'file field required' });
+      return res.status(400).json({ error: RU.fileFieldRequired });
     }
     const p = req.file.path;
-    let size = 0;
+    const { mimetype, originalname } = req.file;
+    let size;
+    let extractedText;
     try {
       const st = await fs.stat(p);
       size = st.size;
-      await fs.unlink(p);
-    } catch {
+      extractedText = await extractTextFromFile(mimetype, p, originalname);
+    } catch (e) {
       try {
         await fs.unlink(p);
       } catch {
         // ignore
       }
-      return res.status(500).json({ error: 'upload failed' });
+      if (e.status) {
+        return res.status(e.status).json({ error: e.message });
+      }
+      console.error('import document:', e);
+      return res.status(500).json({ error: RU.uploadFailed });
     }
+    try {
+      await fs.unlink(p);
+    } catch {
+      // D.5: временный файл удалён; при ошибке extract уже удалили выше
+    }
+    const generation = await generationForImportDocument(extractedText);
     res.json({
       received: true,
-      originalName: req.file.originalname,
+      originalName: originalname,
+      mime: mimetype,
       size,
-      message:
-        'Файл принят; извлечение текста и генерация (D.2–D.3) — в следующем шаге',
+      extractedText,
+      textLength: extractedText.length,
+      generation,
     });
   })
 );
@@ -65,15 +111,19 @@ router.get(
   '/',
   authenticate,
   asyncHandler(async (req, res) => {
-    const { rows } = await query(
+    const { rows } = await queryTestsVisibleToUser(req.user.id);
+    const { rows: hidden } = await query(
       `SELECT t.id, t.title, t.description, t.is_active AS chain_active,
-              t.created_at, t.updated_at, tv.id AS active_version_id, tv.version
+              t.created_at, t.updated_at, tv.id AS active_version_id, tv.version,
+              t.created_by, u.full_name AS author_full_name
        FROM tests t
        INNER JOIN test_versions tv ON tv.test_id = t.id AND tv.is_active = true
-       WHERE t.is_active = true
-       ORDER BY t.updated_at DESC NULLS LAST, t.created_at DESC`
+       INNER JOIN users u ON u.id = t.created_by
+       WHERE t.is_active = false AND t.created_by = $1
+       ORDER BY t.updated_at DESC NULLS LAST, t.created_at DESC`,
+      [req.user.id]
     );
-    res.json({ tests: rows });
+    res.json({ tests: rows, hiddenByYou: hidden });
   })
 );
 
@@ -83,7 +133,7 @@ router.post(
   asyncHandler(async (req, res) => {
     const { title, description } = req.body;
     if (!title || typeof title !== 'string') {
-      return res.status(400).json({ error: 'title required' });
+      return res.status(400).json({ error: RU.titleRequired });
     }
     const out = await createTestWithVersion(pool, req.user.id, {
       title,
@@ -93,27 +143,172 @@ router.post(
   })
 );
 
+/**
+ * V.8: краткая карточка цепочки — одна строка (активная версия), без дублей.
+ * Не-автор не видит скрытую с общего списка цепочку (кроме прямой ссылки автора).
+ */
+router.get(
+  '/:id/summary',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const testId = req.params.id;
+    const { rows } = await query(
+      `SELECT t.id, t.title, t.description, t.passing_threshold, t.is_active AS chain_active,
+              t.created_by, t.created_at, t.updated_at, tv.id AS active_version_id, tv.version,
+              u.full_name AS author_full_name
+       FROM tests t
+       LEFT JOIN test_versions tv ON tv.test_id = t.id AND tv.is_active = true
+       LEFT JOIN users u ON u.id = t.created_by
+       WHERE t.id = $1`,
+      [testId]
+    );
+    if (!rows.length) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    const row = rows[0];
+    const isAuthor = isTestAuthor(row.created_by, req.user.id);
+    if (row.chain_active === false && !isAuthor) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    if (!isAuthor) {
+      const acc = await userHasTestAccess(req.user.id, testId);
+      if (!acc.ok) {
+        return res.status(404).json({ error: RU.testNotFound });
+      }
+    }
+    res.json({
+      test: {
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        passingThreshold: row.passing_threshold,
+        chainActive: row.chain_active,
+        activeVersionId: row.active_version_id,
+        version: row.version,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        createdBy: row.created_by,
+        authorFullName: row.author_full_name,
+      },
+      isAuthor,
+      hasActiveVersion: row.active_version_id != null,
+    });
+  })
+);
+
 router.get(
   '/:id/versions',
   authenticate,
   asyncHandler(async (req, res) => {
     const testId = req.params.id;
-    const { rows: t } = await query(`SELECT id, created_by FROM tests WHERE id = $1`, [
-      testId,
-    ]);
+    const { rows: t } = await query(
+      `SELECT t.id, t.title, t.created_by, t.is_active, t.created_at, t.updated_at, t.description,
+              u.full_name AS author_full_name
+       FROM tests t
+       INNER JOIN users u ON u.id = t.created_by
+       WHERE t.id = $1`,
+      [testId]
+    );
     if (!t.length) {
-      return res.status(404).json({ error: 'Test not found' });
+      return res.status(404).json({ error: RU.testNotFound });
     }
-    if (t[0].created_by !== req.user.id) {
-      return res.status(403).json({ error: 'Forbidden' });
+    if (!isTestAuthor(t[0].created_by, req.user.id)) {
+      return res.status(403).json({ error: RU.forbidden });
     }
+    const testRow = t[0];
     const { rows } = await query(
       `SELECT id, version, is_active, parent_id, created_at
        FROM test_versions WHERE test_id = $1 ORDER BY version`,
       [testId]
     );
     const hasAttempts = await hasAnyAttemptForTest(pool, testId);
-    res.json({ versions: rows, hasAttempts });
+    res.json({
+      test: {
+        id: testRow.id,
+        title: testRow.title,
+        description: testRow.description,
+        chainActive: testRow.is_active,
+        createdAt: testRow.created_at,
+        updatedAt: testRow.updated_at,
+        createdBy: testRow.created_by,
+        authorFullName: testRow.author_full_name,
+      },
+      versions: rows,
+      hasAttempts,
+    });
+  })
+);
+
+router.get(
+  '/:id/editor',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const out = await getEditorContent(pool, req.user.id, req.params.id);
+    res.json(out);
+  })
+);
+
+/**
+ * ИИ: заполнить тест по текущей сетке (число вопросов = len(shape), варианты = optionsCount).
+ * Только автор. Тело: { testTitle?, testDescription?, shape: [{ optionsCount, hasMultipleAnswers }] }
+ */
+router.post(
+  '/:id/ai/generate-test',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const testId = req.params.id;
+    const { rows: t } = await query(
+      `SELECT id, created_by FROM tests WHERE id = $1`,
+      [testId]
+    );
+    if (!t.length) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    if (!isTestAuthor(t[0].created_by, req.user.id)) {
+      return res.status(403).json({ error: RU.forbidden });
+    }
+    const b = req.body && typeof req.body === 'object' ? req.body : {};
+    const shape = parseAndValidateShape(b.shape);
+    const testTitle = typeof b.testTitle === 'string' ? b.testTitle : '';
+    const testDescription = typeof b.testDescription === 'string' ? b.testDescription : '';
+    const draft = await generateFullTestByShape(testTitle, testDescription, shape);
+    res.json({ ok: true, draft });
+  })
+);
+
+/**
+ * ИИ: один вопрос — пустой текст → сгенерировать вопрос и варианты; иначе переформулировать только текст.
+ * Только автор. Тело: { testTitle?, testDescription?, questionText, optionsCount, hasMultipleAnswers }
+ */
+router.post(
+  '/:id/ai/generate-question',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const testId = req.params.id;
+    const { rows: tr } = await query(
+      `SELECT id, created_by FROM tests WHERE id = $1`,
+      [testId]
+    );
+    if (!tr.length) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    if (!isTestAuthor(tr[0].created_by, req.user.id)) {
+      return res.status(403).json({ error: RU.forbidden });
+    }
+    const b = req.body && typeof req.body === 'object' ? req.body : {};
+    const testTitle = typeof b.testTitle === 'string' ? b.testTitle : '';
+    const testDescription = typeof b.testDescription === 'string' ? b.testDescription : '';
+    const questionText = typeof b.questionText === 'string' ? b.questionText : '';
+    const optionsCount = b.optionsCount;
+    const hasMultipleAnswers = Boolean(b.hasMultipleAnswers);
+    const out = await generateOrRephraseQuestion(
+      testTitle,
+      testDescription,
+      questionText,
+      optionsCount,
+      hasMultipleAnswers
+    );
+    res.json({ ok: true, ...out });
   })
 );
 
@@ -128,17 +323,17 @@ router.post(
       [testId]
     );
     if (!t.length) {
-      return res.status(404).json({ error: 'Test not found' });
+      return res.status(404).json({ error: RU.testNotFound });
     }
-    if (t[0].created_by !== req.user.id) {
-      return res.status(403).json({ error: 'Forbidden' });
+    if (!isTestAuthor(t[0].created_by, req.user.id)) {
+      return res.status(403).json({ error: RU.forbidden });
     }
     const { rows: v } = await query(
       `SELECT id FROM test_versions WHERE test_id = $1 AND id = $2`,
       [testId, versionId]
     );
     if (!v.length) {
-      return res.status(404).json({ error: 'Version not found' });
+      return res.status(404).json({ error: RU.versionNotFound });
     }
     const client = await pool.connect();
     try {
@@ -170,17 +365,17 @@ router.patch(
     const { isActive, chainActive } = req.body;
     const chain = chainActive ?? isActive;
     if (typeof chain !== 'boolean') {
-      return res.status(400).json({ error: 'chainActive (boolean) required' });
+      return res.status(400).json({ error: RU.chainActiveRequired });
     }
     const { rows: t } = await query(
       `SELECT id, created_by FROM tests WHERE id = $1`,
       [testId]
     );
     if (!t.length) {
-      return res.status(404).json({ error: 'Test not found' });
+      return res.status(404).json({ error: RU.testNotFound });
     }
-    if (t[0].created_by !== req.user.id) {
-      return res.status(403).json({ error: 'Forbidden' });
+    if (!isTestAuthor(t[0].created_by, req.user.id)) {
+      return res.status(403).json({ error: RU.forbidden });
     }
     await query(
       `UPDATE tests SET is_active = $2, updated_at = CURRENT_TIMESTAMP WHERE id = $1`,
@@ -190,6 +385,111 @@ router.patch(
   })
 );
 
+/**
+ * Пакетное назначение — `test_assignments` + `test_assignment_targets` (user).
+ * Включение: `development` или `CLINIC_ASSIGNMENT_ENABLED=1`. Только автор. Тело: `userIds`, `staffIds` и/или одиночные `userId` / `staffId`.
+ */
+router.post(
+  '/:id/assign',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    if (!isAssignmentFeatureEnabled()) {
+      return res.status(404).json({ error: RU.notFound });
+    }
+    const testId = req.params.id;
+    const b = req.body && typeof req.body === 'object' ? req.body : {};
+    const userIds = new Set();
+
+    if (Array.isArray(b.userIds)) {
+      for (const u of b.userIds) {
+        if (typeof u === 'string' && u.trim()) {
+          userIds.add(u.trim());
+        }
+      }
+    }
+    if (Array.isArray(b.staffIds)) {
+      for (const s of b.staffIds) {
+        const n = Number(s);
+        if (Number.isFinite(n) && n >= 1) {
+          userIds.add(await ensureClinicUserIdForStaff(pool, n));
+        }
+      }
+    }
+    if (userIds.size === 0) {
+      if (b.staffId != null && b.userId) {
+        return res.status(400).json({ error: RU.assignmentUserOrStaff });
+      }
+      if (b.staffId != null) {
+        const sid = Number(b.staffId);
+        if (Number.isNaN(sid)) {
+          return res.status(400).json({ error: RU.assignmentUserRequired });
+        }
+        userIds.add(await ensureClinicUserIdForStaff(pool, sid));
+      } else if (typeof b.userId === 'string' && b.userId.trim()) {
+        userIds.add(b.userId.trim());
+      }
+    }
+    if (userIds.size === 0) {
+      return res.status(400).json({ error: RU.assignmentUserRequired });
+    }
+
+    const { rows: t } = await query(
+      `SELECT id, created_by FROM tests WHERE id = $1`,
+      [testId]
+    );
+    if (!t.length) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    if (!isTestAuthor(t[0].created_by, req.user.id)) {
+      return res.status(403).json({ error: RU.forbidden });
+    }
+    const { rows: tv } = await query(
+      `SELECT id FROM test_versions WHERE test_id = $1 AND is_active = true LIMIT 1`,
+      [testId]
+    );
+    if (!tv.length) {
+      return res.status(400).json({ error: RU.noActiveVersion });
+    }
+    for (const uid of userIds) {
+      const { rows: u } = await query(
+        `SELECT id FROM users WHERE id = $1 AND is_active = true`,
+        [uid]
+      );
+      if (!u.length) {
+        return res.status(400).json({ error: RU.userNotFound });
+      }
+    }
+    const versionId = tv[0].id;
+    const client = await pool.connect();
+    let assignmentId;
+    try {
+      await client.query('BEGIN');
+      const { rows: ins } = await client.query(
+        `INSERT INTO test_assignments (test_version_id, assigned_by, max_attempts)
+         VALUES ($1, $2, 5) RETURNING id`,
+        [versionId, req.user.id]
+      );
+      assignmentId = ins[0].id;
+      for (const uid of userIds) {
+        await client.query(
+          `INSERT INTO test_assignment_targets (assignment_id, target_type, target_id)
+         VALUES ($1, 'user', $2)`,
+          [assignmentId, uid]
+        );
+      }
+      await client.query('COMMIT');
+    } catch (e) {
+      await client.query('ROLLBACK');
+      throw e;
+    } finally {
+      client.release();
+    }
+    res
+      .status(201)
+      .json({ ok: true, assignmentId, count: userIds.size });
+  })
+);
+
 router.post(
   '/:id/draft',
   authenticate,
@@ -204,6 +504,10 @@ router.post(
   authenticate,
   asyncHandler(async (req, res) => {
     const testId = req.params.id;
+    const acc = await userHasTestAccess(req.user.id, testId);
+    if (!acc.ok) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
     const { rows: tv } = await query(
       `SELECT tv.id AS test_version_id
        FROM test_versions tv
@@ -211,7 +515,7 @@ router.post(
       [testId]
     );
     if (!tv.length) {
-      return res.status(404).json({ error: 'No active version' });
+      return res.status(404).json({ error: RU.noActiveVersion });
     }
     const testVersionId = tv[0].test_version_id;
     const { rows: mx } = await query(
@@ -230,11 +534,98 @@ router.post(
   })
 );
 
+/** Только автор: список попыток по цепочке (все версии) */
+router.get(
+  '/:id/attempts',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const rows = await listTestAttemptsForAuthor(pool, req.user.id, req.params.id);
+    res.json({
+      attempts: rows.map((r) => ({
+        id: r.id,
+        userId: r.user_id,
+        status: r.status,
+        attemptNumber: r.attempt_number,
+        startedAt: r.started_at,
+        completedAt: r.completed_at,
+        correctCount: r.correct_count,
+        totalQuestions: r.total_questions,
+        passed: r.passed,
+        testVersion: r.test_version,
+        attempterName: r.attempter_name,
+        attempterLogin: r.attempter_login,
+      })),
+    });
+  })
+);
+
+/** Разбор завершённой попытки: владелец или автор */
+router.get(
+  '/:id/attempts/:aid/review',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const review = await getAttemptReviewForUser(
+      pool,
+      req.user.id,
+      req.params.id,
+      req.params.aid
+    );
+    res.json(review);
+  })
+);
+
+router.get(
+  '/:id/attempts/:aid/play',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const out = await getPlayContent(pool, req.user.id, req.params.id, req.params.aid);
+    res.json(out);
+  })
+);
+
+router.post(
+  '/:id/attempts/:aid/submit',
+  authenticate,
+  asyncHandler(async (req, res) => {
+    const out = await submitAttempt(
+      pool,
+      req.user.id,
+      req.params.id,
+      req.params.aid,
+      req.body?.answers
+    );
+    res.json(out);
+  })
+);
+
 router.get(
   '/:id/chain-info',
   authenticate,
   asyncHandler(async (req, res) => {
     const testId = req.params.id;
+    const acc = await userHasTestAccess(req.user.id, testId);
+    if (acc.notFound) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    if (!acc.ok) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    const { rows: tr } = await query(
+      `SELECT t.is_active AS chain_active FROM tests t WHERE t.id = $1`,
+      [testId]
+    );
+    if (!tr.length) {
+      return res.status(404).json({ error: RU.testNotFound });
+    }
+    if (tr[0].chain_active === false) {
+      const { rows: auth } = await query(
+        `SELECT created_by FROM tests WHERE id = $1`,
+        [testId]
+      );
+      if (!isTestAuthor(auth[0].created_by, req.user.id)) {
+        return res.status(404).json({ error: RU.testNotFound });
+      }
+    }
     const has = await hasAnyAttemptForTest(pool, testId);
     res.json({ testId, hasAnyAttempt: has });
   })
diff --git a/backend/src/services/testAccessService.js b/backend/src/services/testAccessService.js
new file mode 100644
index 0000000..f809110
--- /dev/null
+++ b/backend/src/services/testAccessService.js
@@ -0,0 +1,64 @@
+/**
+ * Кто видит тест: автор цепочки и пользователи с назначением (target user = clinic user id).
+ */
+import { isTestAuthor } from '../config/devAuthor.js';
+import { query } from '../db/db.js';
+
+/**
+ * @param {string} userId
+ * @param {string} testId
+ * @returns {Promise<{ ok: boolean, isAuthor: boolean, notFound: boolean }>}
+ */
+export async function userHasTestAccess(userId, testId) {
+  const { rows } = await query(
+    `SELECT t.created_by FROM tests t WHERE t.id = $1`,
+    [testId]
+  );
+  if (!rows.length) {
+    return { ok: false, isAuthor: false, notFound: true };
+  }
+  if (isTestAuthor(rows[0].created_by, userId)) {
+    return { ok: true, isAuthor: true, notFound: false };
+  }
+  const { rows: ar } = await query(
+    `SELECT 1
+     FROM test_assignments ta
+     INNER JOIN test_versions tv_a ON tv_a.id = ta.test_version_id
+     INNER JOIN test_assignment_targets tat ON tat.assignment_id = ta.id
+     WHERE tv_a.test_id = $1
+       AND tat.target_type = 'user'
+       AND tat.target_id = $2
+     LIMIT 1`,
+    [testId, userId]
+  );
+  return { ok: ar.length > 0, isAuthor: false, notFound: false };
+}
+
+/**
+ * Список тестов в каталоге: только `is_active` цепочка + (автор OR назначен).
+ */
+export async function queryTestsVisibleToUser(userId) {
+  return query(
+    `SELECT DISTINCT t.id, t.title, t.description, t.is_active AS chain_active,
+            t.created_at, t.updated_at, tv.id AS active_version_id, tv.version,
+            t.created_by, u.full_name AS author_full_name
+     FROM tests t
+     INNER JOIN test_versions tv ON tv.test_id = t.id AND tv.is_active = true
+     INNER JOIN users u ON u.id = t.created_by
+     WHERE t.is_active = true
+       AND (
+         t.created_by = $1
+         OR EXISTS (
+           SELECT 1
+           FROM test_assignments ta
+           INNER JOIN test_versions tv2 ON tv2.id = ta.test_version_id
+           INNER JOIN test_assignment_targets tat ON tat.assignment_id = ta.id
+           WHERE tv2.test_id = t.id
+             AND tat.target_type = 'user'
+             AND tat.target_id = $1
+         )
+       )
+     ORDER BY t.updated_at DESC NULLS LAST, t.created_at DESC`,
+    [userId]
+  );
+}
diff --git a/frontend/src/components/CabinetLayout.jsx b/frontend/src/components/CabinetLayout.jsx
new file mode 100644
index 0000000..9f5920c
--- /dev/null
+++ b/frontend/src/components/CabinetLayout.jsx
@@ -0,0 +1,102 @@
+import { useCallback, useEffect, useState } from 'react';
+import { Link, Outlet, useNavigate } from 'react-router-dom';
+import { api } from '../api';
+import { formatSurnameWithInitials } from '../utils/formatUserName';
+
+export default function CabinetLayout() {
+  const nav = useNavigate();
+  const [user, setUser] = useState(null);
+  /** Backend: `devUi` при NODE_ENV=development */
+  const [devUi, setDevUi] = useState(false);
+  /** Каталог HR + блок назначения (env CLINIC_ASSIGNMENT_ENABLED в prod) */
+  const [assignmentUi, setAssignmentUi] = useState(false);
+  const [loading, setLoading] = useState(true);
+  const [err, setErr] = useState(null);
+
+  const loadMe = useCallback(async () => {
+    setErr(null);
+    try {
+      const me = await api('/api/auth/me');
+      setUser(me.user);
+      setDevUi(!!me.devUi);
+      setAssignmentUi(!!me.assignmentUi);
+    } catch (e) {
+      if (e.status === 401) {
+        nav('/login', { replace: true });
+        return;
+      }
+      setErr(e.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [nav]);
+
+  useEffect(() => {
+    loadMe();
+  }, [loadMe]);
+
+  async function logout() {
+    try {
+      await api('/api/auth/logout', { method: 'POST' });
+    } catch {
+      // ignore; still go to login
+    }
+    nav('/login');
+  }
+
+  if (loading) {
+    return (
+      <div className="cabinet-app cabinet-page--center">
+        <p className="text-muted">Загрузка…</p>
+      </div>
+    );
+  }
+
+  if (err) {
+    return (
+      <div className="cabinet-app cabinet-page--center">
+        <p className="callout callout--error" role="alert">
+          {err}
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="cabinet-app">
+      <header className="cabinet-header">
+        <div className="cabinet-header__inner">
+          <Link to="/tests" className="cabinet-brand">
+            <span
+              className="material-symbols-outlined cabinet-brand__icon"
+              aria-hidden
+            >
+              school
+            </span>
+            <div>
+              <div className="cabinet-brand__title">Система тестрования</div>
+              <div className="cabinet-brand__subtitle">Портал</div>
+            </div>
+          </Link>
+          <div className="cabinet-header__actions">
+            {user && (
+              <span
+                className="cabinet-user"
+                title={user.fullName ? `${user.fullName} · ${user.role}` : user.role}
+              >
+                {formatSurnameWithInitials(user.fullName) || user.login || '—'}
+                <span className="cabinet-user__role"> · {user.role}</span>
+              </span>
+            )}
+            <button type="button" className="btn btn-ghost" onClick={logout}>
+              Выйти
+            </button>
+          </div>
+        </div>
+      </header>
+      <main className="cabinet-main">
+        <Outlet context={{ user, devUi, assignmentUi, refreshUser: loadMe }} />
+      </main>
+    </div>
+  );
+}
diff --git a/frontend/src/pages/TestDetail.jsx b/frontend/src/pages/TestDetail.jsx
index 1bbb49f..66b2460 100644
--- a/frontend/src/pages/TestDetail.jsx
+++ b/frontend/src/pages/TestDetail.jsx
@@ -1,23 +1,132 @@
 import { useEffect, useState } from 'react';
-import { useNavigate, useParams, Link } from 'react-router-dom';
+import { useNavigate, useParams, Link, useOutletContext } from 'react-router-dom';
 import { api } from '../api';
+import { formatTestAuthorLabel } from '../utils/formatUserName';
+
+function fmtDt(iso) {
+  if (!iso) {
+    return '—';
+  }
+  try {
+    return new Date(iso).toLocaleString('ru-RU', {
+      dateStyle: 'short',
+      timeStyle: 'short',
+    });
+  } catch {
+    return '—';
+  }
+}
+
+function newKey() {
+  return globalThis.crypto?.randomUUID?.() ?? `k-${Date.now()}-${Math.random()}`;
+}
+
+function createEmptyQuestion() {
+  return {
+    key: newKey(),
+    text: '',
+    hasMultipleAnswers: false,
+    options: [
+      { key: newKey(), text: '', isCorrect: true },
+      { key: newKey(), text: '', isCorrect: false },
+    ],
+  };
+}
+
+/**
+ * @param {{ title: string, defaultOpen?: boolean, id?: string, children: import('react').ReactNode }} p
+ */
+function AccSection({ title, defaultOpen, id, children }) {
+  return (
+    <div className="cabinet-brick">
+      <details className="cabinet-disclosure" defaultOpen={defaultOpen} id={id || undefined}>
+        <summary className="cabinet-disclosure__summary font-headline">{title}</summary>
+        <div className="cabinet-disclosure__body">{children}</div>
+      </details>
+    </div>
+  );
+}
+
+function mapEditorToDraftQuestions(ed) {
+  if (!ed?.questions?.length) {
+    return [createEmptyQuestion()];
+  }
+  return ed.questions.map((q) => ({
+    key: String(q.id),
+    id: q.id,
+    text: q.text ?? '',
+    hasMultipleAnswers: !!q.hasMultipleAnswers,
+    options: (q.options || []).map((o) => ({
+      key: String(o.id),
+      id: o.id,
+      text: o.text ?? '',
+      isCorrect: !!o.isCorrect,
+    })),
+  }));
+}
 
 export default function TestDetail() {
   const { id } = useParams();
   const nav = useNavigate();
+  const { user, assignmentUi } = useOutletContext() || {};
   const [data, setData] = useState(null);
+  /** V.8: сотрудник / не-автор — краткая карточка без редактора */
+  const [taker, setTaker] = useState(null);
   const [chain, setChain] = useState(null);
   const [err, setErr] = useState(null);
-  const [qText, setQText] = useState('Пример вопроса?');
+  const [draftTitle, setDraftTitle] = useState('');
+  const [draftDescription, setDraftDescription] = useState('');
+  const [draftPassing, setDraftPassing] = useState('70');
+  const [draftQuestions, setDraftQuestions] = useState(() => [createEmptyQuestion()]);
   const [draftStatus, setDraftStatus] = useState('');
+  const [deactivateBusy, setDeactivateBusy] = useState(false);
+  const [importPreview, setImportPreview] = useState(null);
+  const [importErr, setImportErr] = useState(null);
+  const [importBusy, setImportBusy] = useState(false);
+  const [aiTestBusy, setAiTestBusy] = useState(false);
+  const [aiQBusy, setAiQBusy] = useState(null);
+  const [assignSearch, setAssignSearch] = useState('');
+  const [assignSearchApplied, setAssignSearchApplied] = useState('');
+  const [assignDept, setAssignDept] = useState('__all__');
+  const [assignClinic, setAssignClinic] = useState('all');
+  const [assignPeople, setAssignPeople] = useState([]);
+  const [assignDepts, setAssignDepts] = useState([]);
+  const [assignSource, setAssignSource] = useState('');
+  const [assignSelected, setAssignSelected] = useState(() => new Set());
+  const [assignMsg, setAssignMsg] = useState('');
+  const [assignErr, setAssignErr] = useState(null);
+  const [assignLoadBusy, setAssignLoadBusy] = useState(false);
+  const [attemptsList, setAttemptsList] = useState(undefined);
+  const [attemptsErr, setAttemptsErr] = useState(null);
 
   async function load() {
     setErr(null);
+    setData(null);
+    setTaker(null);
+    setChain(null);
     try {
-      const v = await api(`/api/tests/${id}/versions`);
-      const c = await api(`/api/tests/${id}/chain-info`);
+      const sum = await api(`/api/tests/${id}/summary`);
+      if (!sum.isAuthor) {
+        const c = await api(`/api/tests/${id}/chain-info`);
+        setTaker({ summary: sum, chain: c });
+        return;
+      }
+      const [v, c, ed] = await Promise.all([
+        api(`/api/tests/${id}/versions`),
+        api(`/api/tests/${id}/chain-info`),
+        api(`/api/tests/${id}/editor`),
+      ]);
       setData(v);
       setChain(c);
+      if (ed?.test) {
+        setDraftTitle(ed.test.title || '');
+        setDraftDescription(ed.test.description || '');
+        const th = ed.test.passingThreshold;
+        setDraftPassing(
+          th !== undefined && th !== null && String(th) !== '' ? String(th) : '70'
+        );
+        setDraftQuestions(mapEditorToDraftQuestions(ed));
+      }
     } catch (e) {
       if (e.status === 401) {
         nav('/login');
@@ -31,25 +140,159 @@ export default function TestDetail() {
     load();
   }, [id, nav]);
 
+  useEffect(() => {
+    if (!data) {
+      setAttemptsList(undefined);
+      setAttemptsErr(null);
+      return;
+    }
+    let cancelled = false;
+    setAttemptsErr(null);
+    (async () => {
+      try {
+        const r = await api(`/api/tests/${id}/attempts`);
+        if (!cancelled) {
+          setAttemptsList(r.attempts || []);
+        }
+      } catch (e) {
+        if (!cancelled) {
+          if (e.status === 403 || e.status === 404) {
+            setAttemptsList(null);
+          } else {
+            setAttemptsErr(e.message);
+            setAttemptsList(null);
+          }
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [data, id]);
+
+  useEffect(() => {
+    const t = setTimeout(() => setAssignSearchApplied(assignSearch), 400);
+    return () => clearTimeout(t);
+  }, [assignSearch]);
+
+  useEffect(() => {
+    if (!assignmentUi || !data) {
+      return;
+    }
+    let cancelled = false;
+    (async () => {
+      setAssignErr(null);
+      setAssignLoadBusy(true);
+      try {
+        const params = new URLSearchParams();
+        if (assignSearchApplied.trim()) {
+          params.set('q', assignSearchApplied.trim());
+        }
+        if (assignDept && assignDept !== '__all__') {
+          params.set('department', assignDept);
+        }
+        params.set('clinic', assignClinic);
+        const r = await api(`/api/auth/dev/assignment-directory?${params.toString()}`);
+        if (cancelled) {
+          return;
+        }
+        setAssignPeople(r.people || []);
+        setAssignDepts(r.departments || []);
+        setAssignSource(r.source || '');
+        setAssignSelected(new Set());
+      } catch (e) {
+        if (!cancelled) {
+          setAssignErr(e.message);
+        }
+      } finally {
+        if (!cancelled) {
+          setAssignLoadBusy(false);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [assignmentUi, data, id, assignSearchApplied, assignDept, assignClinic]);
+
+  function assignPersonKey(p) {
+    return `${p.staffId ?? '—'}|${p.clinicUserId ?? '—'}`;
+  }
+
+  function toggleAssignPerson(p) {
+    const k = assignPersonKey(p);
+    setAssignSelected((prev) => {
+      const next = new Set(prev);
+      if (next.has(k)) {
+        next.delete(k);
+      } else {
+        next.add(k);
+      }
+      return next;
+    });
+  }
+
+  async function postAssign() {
+    const selectedRows = assignPeople.filter((p) =>
+      assignSelected.has(assignPersonKey(p))
+    );
+    if (selectedRows.length === 0) {
+      return;
+    }
+    setAssignMsg('');
+    setAssignErr(null);
+    const userIds = [];
+    const staffIds = [];
+    for (const p of selectedRows) {
+      if (p.clinicUserId) {
+        userIds.push(p.clinicUserId);
+      } else if (p.staffId != null) {
+        staffIds.push(p.staffId);
+      }
+    }
+    if (userIds.length === 0 && staffIds.length === 0) {
+      setAssignErr('Не выбраны сотрудники с валидным staff_id.');
+      return;
+    }
+    try {
+      const out = await api(`/api/tests/${id}/assign`, {
+        method: 'POST',
+        body: JSON.stringify({ userIds, staffIds }),
+      });
+      setAssignMsg(
+        out.count != null
+          ? `Создано назначение на ${out.count} сотр. (dev).`
+          : 'Назначение в БД создано (dev).'
+      );
+      setAssignSelected(new Set());
+    } catch (e) {
+      setAssignErr(e.message);
+    }
+  }
+
   async function saveDraft() {
     setDraftStatus('…');
     try {
+      const questions = draftQuestions.map((q, i) => ({
+        text: (q.text || '').trim() || 'Вопрос',
+        question_order: i + 1,
+        hasMultipleAnswers: q.hasMultipleAnswers,
+        options: q.options.map((o, j) => ({
+          text: (o.text || '').trim() || 'Вариант',
+          isCorrect: o.isCorrect,
+          option_order: j + 1,
+        })),
+      }));
       const out = await api(`/api/tests/${id}/draft`, {
         method: 'POST',
         body: JSON.stringify({
-          title: 'Обновлённый заголовок (через черновик)',
-          questions: [
-            {
-              text: qText,
-              question_order: 1,
-              hasMultipleAnswers: false,
-              options: [
-                { text: 'Верно', isCorrect: true, option_order: 1 },
-                { text: 'Неверно 1', isCorrect: false, option_order: 2 },
-                { text: 'Неверно 2', isCorrect: false, option_order: 3 },
-              ],
-            },
-          ],
+          title: (draftTitle || '').trim() || 'Без названия',
+          description: (draftDescription || '').trim() || null,
+          passingThreshold: (() => {
+            const n = Number(draftPassing);
+            return Number.isFinite(n) ? n : undefined;
+          })(),
+          questions,
         }),
       });
       setDraftStatus(
@@ -63,21 +306,225 @@ export default function TestDetail() {
     }
   }
 
-  async function startAttempt() {
+  async function runAiGenerateTest() {
+    if (aiTestBusy || !id) {
+      return;
+    }
+    setDraftStatus('');
+    setAiTestBusy(true);
     try {
-      const o = await api(`/api/tests/${id}/attempts/start`, {
+      const shape = draftQuestions.map((q) => ({
+        optionsCount: Math.max(2, Math.min(12, q.options?.length || 2)),
+        hasMultipleAnswers: q.hasMultipleAnswers,
+      }));
+      const out = await api(`/api/tests/${id}/ai/generate-test`, {
         method: 'POST',
-        body: JSON.stringify({}),
+        body: JSON.stringify({
+          testTitle: draftTitle,
+          testDescription: draftDescription,
+          shape,
+        }),
       });
-      setDraftStatus(`Попытка стартовала: ${o.attempt.id}`);
-      load();
+      if (out.draft) {
+        setDraftTitle((out.draft.title || '').trim() || 'Без названия');
+        setDraftDescription(
+          out.draft.description != null && String(out.draft.description).trim()
+            ? String(out.draft.description).trim()
+            : ''
+        );
+        const qs = (out.draft.questions || []).map((q) => ({
+          key: newKey(),
+          text: (q.text || '').trim() || 'Вопрос',
+          hasMultipleAnswers: !!q.hasMultipleAnswers,
+          options: (q.options || []).map((o) => ({
+            key: newKey(),
+            text: (o.text || '').trim() || 'Вариант',
+            isCorrect: !!o.isCorrect,
+          })),
+        }));
+        if (qs.length) {
+          setDraftQuestions(qs);
+        }
+        setDraftStatus('Тексты и верные варианты сгенерированы по сетке. Проверьте и сохраните.');
+      }
     } catch (e) {
-      setDraftStatus(e.message);
+      setDraftStatus(e.message || 'Ошибка');
+    } finally {
+      setAiTestBusy(false);
+    }
+  }
+
+  async function runAiGenerateQuestion(qi) {
+    if (aiQBusy != null || !id) {
+      return;
+    }
+    setDraftStatus('');
+    const q = draftQuestions[qi];
+    if (!q) {
+      return;
+    }
+    setAiQBusy(qi);
+    try {
+      const out = await api(`/api/tests/${id}/ai/generate-question`, {
+        method: 'POST',
+        body: JSON.stringify({
+          testTitle: draftTitle,
+          testDescription: draftDescription,
+          questionText: (q.text || '').trim(),
+          optionsCount: Math.max(2, Math.min(12, q.options?.length || 2)),
+          hasMultipleAnswers: q.hasMultipleAnswers,
+        }),
+      });
+      if (out.mode === 'rephrase' && out.text) {
+        setDraftQuestions((prev) =>
+          prev.map((row, i) => (i === qi ? { ...row, text: out.text } : row))
+        );
+        setDraftStatus('Вопрос переформулирован. При необходимости сохраните.');
+      } else if (out.mode === 'full') {
+        setDraftQuestions((prev) =>
+          prev.map((row, i) =>
+            i === qi
+              ? {
+                  ...row,
+                  key: newKey(),
+                  text: (out.text || '').trim() || 'Вопрос',
+                  hasMultipleAnswers: !!out.hasMultipleAnswers,
+                  options: (out.options || []).map((o) => ({
+                    key: newKey(),
+                    text: (o.text || '').trim() || 'Вариант',
+                    isCorrect: !!o.isCorrect,
+                  })),
+                }
+              : row
+          )
+        );
+        setDraftStatus('Вопрос и варианты сгенерированы. Проверьте и сохраните.');
+      }
+    } catch (e) {
+      setDraftStatus(e.message || 'Ошибка');
+    } finally {
+      setAiQBusy(null);
     }
   }
 
+  async function onImportFile(e) {
+    const f = e.target.files?.[0];
+    e.target.value = '';
+    if (!f) {
+      return;
+    }
+    setImportErr(null);
+    setImportPreview(null);
+    setImportBusy(true);
+    try {
+      const fd = new FormData();
+      fd.append('file', f);
+      const out = await api('/api/tests/import/document', {
+        method: 'POST',
+        body: fd,
+      });
+      setImportPreview(out);
+    } catch (er) {
+      setImportErr(er.message);
+    } finally {
+      setImportBusy(false);
+    }
+  }
+
+  function applyExtractedToQuestion() {
+    const t = importPreview?.extractedText;
+    if (!t) {
+      return;
+    }
+    const chunk = t.length > 2000 ? `${t.slice(0, 2000)}…` : t;
+    setDraftQuestions((prev) => {
+      if (!prev.length) {
+        const q = createEmptyQuestion();
+        q.text = chunk;
+        return [q];
+      }
+      const next = [...prev];
+      next[0] = { ...next[0], text: chunk };
+      return next;
+    });
+  }
+
+  function applyGeneratedDraft() {
+    const d = importPreview?.generation?.draft;
+    if (!d) {
+      return;
+    }
+    setDraftTitle((d.title || '').trim() || 'Без названия');
+    setDraftDescription(
+      d.description != null && String(d.description).trim() ? String(d.description).trim() : ''
+    );
+    const qs = (d.questions || []).map((q) => {
+      const opts = (q.options || []).map((o) => ({
+        key: newKey(),
+        text: (o.text || '').trim() || 'Вариант',
+        isCorrect: !!o.isCorrect,
+      }));
+      if (opts.length < 2) {
+        return {
+          key: newKey(),
+          text: (q.text || '').trim() || 'Вопрос',
+          hasMultipleAnswers: !!q.hasMultipleAnswers,
+          options: [
+            { key: newKey(), text: 'Вариант 1', isCorrect: true },
+            { key: newKey(), text: 'Вариант 2', isCorrect: false },
+          ],
+        };
+      }
+      return {
+        key: newKey(),
+        text: (q.text || '').trim() || 'Вопрос',
+        hasMultipleAnswers: !!q.hasMultipleAnswers,
+        options: opts,
+      };
+    });
+    setDraftQuestions(qs.length ? qs : [createEmptyQuestion()]);
+    setDraftStatus('Черновик из LLM перенесён в редактор. Сохраните при необходимости.');
+  }
+
+  function addQuestion() {
+    setDraftQuestions((prev) => [...prev, createEmptyQuestion()]);
+  }
+
+  function removeQuestion(index) {
+    setDraftQuestions((prev) => prev.filter((_, i) => i !== index));
+  }
+
+  function addOption(qIndex) {
+    setDraftQuestions((prev) => {
+      const next = prev.map((q, i) =>
+        i === qIndex
+          ? {
+              ...q,
+              options: [...q.options, { key: newKey(), text: '', isCorrect: false }],
+            }
+          : q
+      );
+      return next;
+    });
+  }
+
+  function removeOption(qIndex, oIndex) {
+    setDraftQuestions((prev) => {
+      const next = prev.map((q, i) => {
+        if (i !== qIndex) {
+          return q;
+        }
+        if (q.options.length <= 1) {
+          return q;
+        }
+        return { ...q, options: q.options.filter((_, j) => j !== oIndex) };
+      });
+      return next;
+    });
+  }
+
   async function activateVersion(vid) {
-    if (!window.confirm('Сделать эту версию активной?')) {
+    if (!window.confirm('Сделать эту версию активной? Новые попытки пойдут по выбранной версии.')) {
       return;
     }
     try {
@@ -91,87 +538,676 @@ export default function TestDetail() {
     }
   }
 
+  async function setChainVisible(chainActive) {
+    const act = chainActive ? 'снова показывать' : 'скрывать';
+    if (!window.confirm(`Цепочка будет ${act} в общем списке тестов. Продолжить?`)) {
+      return;
+    }
+    setDeactivateBusy(true);
+    setErr(null);
+    try {
+      await api(`/api/tests/${id}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ chainActive }),
+      });
+      await load();
+    } catch (e) {
+      setErr(e.message);
+    } finally {
+      setDeactivateBusy(false);
+    }
+  }
+
   if (err) {
-    return <p style={{ color: 'coral' }}>{err}</p>;
+    return <p className="error-text">{err}</p>;
   }
-  if (!data) {
-    return <p>Загрузка…</p>;
+  if (!data && !taker) {
+    return <p className="text-muted">Загрузка…</p>;
   }
 
+  if (taker) {
+    const { test: t, hasActiveVersion } = taker.summary;
+    const title = t?.title || 'Тест';
+    return (
+      <div>
+        <p className="link-back">
+          <Link to="/tests">← к списку</Link>
+        </p>
+        <h1
+          className="font-headline"
+          style={{ fontSize: '1.35rem', marginTop: 0, marginBottom: '0.35rem' }}
+        >
+          {title}
+        </h1>
+        <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.4rem', fontSize: 14 }}>
+          {formatTestAuthorLabel(user, t?.createdBy, t?.authorFullName)}
+        </p>
+        <p className="muted" style={{ marginTop: 0, marginBottom: '0.5rem' }}>
+          Режим сотрудника: одна цепочка — одна активная версия (v{t?.version ?? '—'}
+          {t?.activeVersionId && (
+            <span className="code-inline" style={{ marginLeft: 6, fontSize: '0.8rem' }}>
+              · {String(t.activeVersionId).slice(0, 8)}…
+            </span>
+          )}
+          )
+        </p>
+        {t?.description && (
+          <p className="text-muted" style={{ marginTop: 0, marginBottom: '1rem' }}>
+            {t.description}
+          </p>
+        )}
+        <p className="text-muted" style={{ marginTop: 0, marginBottom: '1rem' }}>
+          Порог для зачёта: <strong>{t?.passingThreshold ?? '—'}%</strong>
+        </p>
+        {!hasActiveVersion && (
+          <div className="callout callout--warning" role="status">
+            Активная версия недоступна. Обратитесь к автору теста.
+          </div>
+        )}
+        <p className="text-muted" style={{ marginTop: '1.25rem' }}>
+          Пройдите тест в{' '}
+          <Link to="/tests">каталоге</Link> — в строке с названием слева откроется карточка, справа
+          кнопка «Пройти».
+        </p>
+      </div>
+    );
+  }
+
+  const { test, versions, hasAttempts } = data;
+  const title = test?.title || 'Тест';
+  const assignSelectedInList = assignPeople.filter((p) =>
+    assignSelected.has(assignPersonKey(p))
+  );
+
   return (
-    <div style={{ maxWidth: 900, margin: '24px auto', fontFamily: 'system-ui' }}>
-      <p>
-        <Link to="/tests">← к списку</Link>
-      </p>
-      {chain?.hasAnyAttempt && (
-        <div
-          style={{
-            background: '#fff3cd',
-            border: '1px solid #ffc107',
-            padding: 12,
-            marginBottom: 16,
-          }}
+    <div className="test-detail-page">
+      <div className="cabinet-brick cabinet-brick--hero">
+        <p className="link-back" style={{ marginTop: 0 }}>
+          <Link to="/tests">← к списку</Link>
+        </p>
+
+        <h1
+          className="font-headline"
+          style={{ fontSize: '1.35rem', marginTop: 0, marginBottom: '0.35rem' }}
         >
-          По этой цепочке уже есть попытка. Сохранение черновика с вопросами
-          создаст <strong>новую версию</strong> (V.1–V.3).
+          {title}
+        </h1>
+        <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.5rem', fontSize: 14 }}>
+          {formatTestAuthorLabel(user, test?.createdBy, test?.authorFullName)}
+        </p>
+        <div className="inline-actions" style={{ marginBottom: '0.65rem', flexWrap: 'wrap' }}>
+          <button
+            type="button"
+            className="btn btn-ghost"
+            disabled={aiTestBusy}
+            onClick={runAiGenerateTest}
+          >
+            {aiTestBusy ? 'Генерация…' : 'Сгенерировать тест (ИИ)'}
+          </button>
         </div>
-      )}
+        <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.75rem', fontSize: 13 }}>
+          Заполняет все вопросы и варианты по <strong>текущей структуре</strong> (число карточек
+          вопросов и вариантов в каждой — задайте кнопками «+ вопрос» / «+ вариант»). Верные ответы
+          отмечает модель. Нужен ключ в backend:{' '}
+          <code className="code-inline">DEEPSEEK_API_KEY</code> или{' '}
+          <code className="code-inline">OPENAI_API_KEY</code>.
+        </p>
+        {test?.description && (
+          <p className="text-muted" style={{ marginTop: 0, marginBottom: '1rem' }}>
+            {test.description}
+          </p>
+        )}
+        <p className="muted" style={{ marginBottom: 0 }}>
+          Обновлён: {fmtDt(test?.updatedAt || test?.createdAt)}
+          {test?.chainActive === false && (
+            <span className="error-text" style={{ marginLeft: '0.75rem' }}>
+              · скрыт из списка
+            </span>
+          )}
+        </p>
 
-      <h2>Версии</h2>
-      <table
-        style={{ borderCollapse: 'collapse', width: '100%' }}
-        cellPadding={8}
-      >
-        <thead>
-          <tr>
-            <th>ver</th>
-            <th>id</th>
-            <th>active</th>
-            <th />
-          </tr>
-        </thead>
-        <tbody>
-          {data.versions.map((r) => (
-            <tr key={r.id} style={{ borderTop: '1px solid #ddd' }}>
-              <td>{r.version}</td>
-              <td style={{ fontSize: 12, wordBreak: 'break-all' }}>{r.id}</td>
-              <td>{r.is_active ? 'да' : 'нет'}</td>
-              <td>
-                {!r.is_active && (
-                  <button type="button" onClick={() => activateVersion(r.id)}>
-                    сделать активной
-                  </button>
-                )}
-              </td>
+        {test?.chainActive === false && (
+          <div className="callout callout--warning" role="status" style={{ marginTop: '0.75rem' }}>
+            Эта цепочка <strong>не показывается</strong> в верхнем списке на «Тесты».
+            Карточку всегда можно открыть из раздела <strong>«Скрытые вами из списка»</strong>{' '}
+            на той же странице или по закладке с адресом карточки. Снова включить
+            отображение — в блоке «Публикация»; данные не удаляются.
+          </div>
+        )}
+
+        {chain?.hasAnyAttempt && (
+          <div className="callout callout--warning" role="status" style={{ marginTop: '0.75rem' }}>
+            Уже были попытки по этой цепочке. Сохранение черновика с вопросами создаст{' '}
+            <strong>новую версию</strong> (см. V.1–V.3); старая останется в истории.
+          </div>
+        )}
+        {data && attemptsErr && (
+          <p className="error-text" style={{ marginTop: '0.75rem', marginBottom: 0 }} role="alert">
+            {attemptsErr}
+          </p>
+        )}
+      </div>
+
+      <AccSection title="История версий" defaultOpen={false}>
+        <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.75rem' }}>
+        Активная — та, по которой сейчас идут новые попытки. Можно вручную сделать
+        активной другую строку.
+      </p>
+      <div className="surface-card" style={{ padding: 0, overflow: 'hidden' }}>
+        <table className="table-cabinet">
+          <thead>
+            <tr>
+              <th>Версия</th>
+              <th>Активна</th>
+              <th>Создана</th>
+              <th />
             </tr>
-          ))}
-        </tbody>
-      </table>
-      {data.hasAttempts && (
-        <p style={{ color: '#666', fontSize: 14 }}>hasAttempts: да</p>
+          </thead>
+          <tbody>
+            {versions.map((r) => (
+              <tr key={r.id}>
+                <td>
+                  v{r.version}
+                  {r.is_active && (
+                    <span
+                      className="code-inline"
+                      style={{ marginLeft: '0.5rem', fontSize: '0.7rem' }}
+                    >
+                      текущая
+                    </span>
+                  )}
+                </td>
+                <td>{r.is_active ? 'да' : 'нет'}</td>
+                <td className="mono">{fmtDt(r.created_at)}</td>
+                <td>
+                  {!r.is_active && (
+                    <button
+                      type="button"
+                      className="btn btn-ghost btn--sm"
+                      onClick={() => activateVersion(r.id)}
+                    >
+                      сделать активной
+                    </button>
+                  )}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+      {hasAttempts && (
+        <p className="text-muted" style={{ marginTop: '0.75rem', marginBottom: 0 }}>
+          По цепочке есть зафиксированные прогоны — разбор идёт по той версии, с
+          которой проходили.
+        </p>
+      )}
+      </AccSection>
+
+      {attemptsList != null && attemptsList.length > 0 && (
+        <AccSection title="Прогоны и разбор" defaultOpen={false}>
+          <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.75rem' }}>
+            Попытки по всем версиям цепочки. Подробный разбор вариантов — для завершённых
+            прогонов.
+          </p>
+          {attemptsErr && (
+            <p className="error-text" role="alert">
+              {attemptsErr}
+            </p>
+          )}
+          <div className="surface-card" style={{ padding: 0, overflow: 'auto' }}>
+            <table className="table-cabinet">
+              <thead>
+                <tr>
+                  <th>Когда</th>
+                  <th>Участник</th>
+                  <th>v</th>
+                  <th>Результат</th>
+                  <th />
+                </tr>
+              </thead>
+              <tbody>
+                {attemptsList.map((a) => (
+                  <tr key={a.id}>
+                    <td className="mono" style={{ whiteSpace: 'nowrap' }}>
+                      {a.completedAt
+                        ? fmtDt(a.completedAt)
+                        : a.startedAt
+                          ? fmtDt(a.startedAt)
+                          : '—'}
+                    </td>
+                    <td>
+                      {a.attempterName || '—'}
+                      {a.attempterLogin && (
+                        <span className="code-inline" style={{ fontSize: 11, marginLeft: 6 }}>
+                          {a.attempterLogin}
+                        </span>
+                      )}
+                    </td>
+                    <td>v{a.testVersion}</td>
+                    <td>
+                      {a.status === 'completed' && a.totalQuestions != null ? (
+                        <>
+                          {a.correctCount}/{a.totalQuestions}
+                          {a.passed ? ' · зачёт' : ' · незачёт'}
+                        </>
+                      ) : (
+                        a.status
+                      )}
+                    </td>
+                    <td>
+                      {a.status === 'completed' && (
+                        <Link
+                          to={`/tests/${id}/attempts/${a.id}/review`}
+                          className="btn btn-ghost btn--sm"
+                        >
+                          Разбор
+                        </Link>
+                      )}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </AccSection>
+      )}
+
+      <AccSection title="Публикация (видимость в списке)" defaultOpen={false}>
+      <p className="text-muted" style={{ marginTop: 0 }}>
+        Деактивация убирает тест из общего списка; карточка открывается по прямой
+        ссылке.
+      </p>
+      <div className="inline-actions" style={{ marginTop: '0.5rem' }}>
+        {test?.chainActive !== false ? (
+          <button
+            type="button"
+            className="btn btn-ghost"
+            disabled={deactivateBusy}
+            onClick={() => setChainVisible(false)}
+          >
+            Скрыть из списка
+          </button>
+        ) : (
+          <button
+            type="button"
+            className="btn btn-ghost"
+            disabled={deactivateBusy}
+            onClick={() => setChainVisible(true)}
+          >
+            Снова показать в списке
+          </button>
+        )}
+      </div>
+      </AccSection>
+
+      <AccSection title="Импорт из файла" defaultOpen={false}>
+      <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.5rem' }}>
+        PDF, DOCX, TXT/MD, до 10 МБ. Текст извлекается на сервере; при{' '}
+        <code className="code-inline">DEEPSEEK_API_KEY</code> или{' '}
+        <code className="code-inline">OPENAI_API_KEY</code> в backend строится черновик теста
+        (см. <code className="code-inline">generation.draft</code>).
+      </p>
+      <div className="inline-actions" style={{ marginBottom: '0.5rem' }}>
+        <input
+          type="file"
+          accept=".pdf,.docx,.txt,.md,application/pdf"
+          onChange={onImportFile}
+          disabled={importBusy}
+          aria-label="Выбрать файл для импорта"
+        />
+        {importBusy && <span className="text-muted">Обработка…</span>}
+      </div>
+      {importErr && (
+        <p className="error-text" role="alert">
+          {importErr}
+        </p>
+      )}
+      {importPreview && (
+        <div className="draft-block" style={{ marginBottom: '1rem' }}>
+          <p className="muted" style={{ marginTop: 0 }}>
+            {importPreview.generation?.message}
+          </p>
+          {importPreview.generation?.textPreview && !importPreview.generation?.available && (
+            <pre
+              className="form-input"
+              style={{
+                maxHeight: 180,
+                overflow: 'auto',
+                fontSize: 13,
+                marginTop: 8,
+                whiteSpace: 'pre-wrap',
+              }}
+            >
+              {importPreview.generation.textPreview}
+              {importPreview.textLength > 4000 ? '…' : ''}
+            </pre>
+          )}
+          {importPreview.generation?.draft && (
+            <div className="inline-actions" style={{ marginTop: 8 }}>
+              <button
+                type="button"
+                className="btn btn-ghost"
+                onClick={applyGeneratedDraft}
+              >
+                Применить сгенерированный черновик
+              </button>
+            </div>
+          )}
+          {importPreview.extractedText && (
+            <div className="inline-actions" style={{ marginTop: 8 }}>
+              <button
+                type="button"
+                className="btn btn-ghost"
+                onClick={applyExtractedToQuestion}
+              >
+                Вставить в первый вопрос (до 2000 симв.)
+              </button>
+            </div>
+          )}
+        </div>
       )}
+      </AccSection>
 
-      <h3>Черновик (V.3)</h3>
-      <label>
-        Текст вопроса
-        <br />
+      <AccSection title="Содержание: название, порог, вопросы" defaultOpen>
+        <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.75rem' }}>
+        Редактируется активная версия. Сохранение отправляет вопросы на сервер; при уже
+        существующих попытках по цепочке создаётся новая версия с копией контента.
+        Порог зачёта — в таблице <code className="code-inline">tests</code>, на все
+        версии цепочки.
+      </p>
+      <div className="draft-block">
+        <label className="form-label" htmlFor="draft-title">
+          Название
+        </label>
         <input
-          value={qText}
-          onChange={(e) => setQText(e.target.value)}
-          style={{ width: '100%', padding: 8, marginTop: 4 }}
+          id="draft-title"
+          className="form-input"
+          value={draftTitle}
+          onChange={(e) => setDraftTitle(e.target.value)}
+        />
+        <label className="form-label" htmlFor="draft-desc" style={{ marginTop: '0.75rem' }}>
+          Описание
+        </label>
+        <textarea
+          id="draft-desc"
+          className="form-input"
+          rows={2}
+          value={draftDescription}
+          onChange={(e) => setDraftDescription(e.target.value)}
         />
-      </label>
-      <div style={{ marginTop: 8 }}>
-        <button type="button" onClick={saveDraft}>
-          Сохранить черновик
-        </button>
-        <span style={{ marginLeft: 12, color: '#666' }}>{draftStatus}</span>
+        <label className="form-label" htmlFor="draft-pass" style={{ marginTop: '0.75rem' }}>
+          Порог зачёта, %
+        </label>
+        <p className="text-muted" style={{ marginTop: 0, marginBottom: 6, fontSize: 13 }}>
+          Минимум правильных ответов (в процентах) для «зачёта»; по умолчанию в БД 70.
+        </p>
+        <input
+          id="draft-pass"
+          type="number"
+          className="form-input"
+          min={0}
+          max={100}
+          inputMode="numeric"
+          value={draftPassing}
+          onChange={(e) => setDraftPassing(e.target.value)}
+          style={{ maxWidth: 120 }}
+        />
+        {draftQuestions.map((q, qi) => (
+          <div
+            key={q.key}
+            style={{
+              borderTop: '1px solid var(--border-subtle, #2a2a2a)',
+              marginTop: '1rem',
+              paddingTop: '1rem',
+            }}
+          >
+            <div
+              className="inline-actions"
+              style={{ marginBottom: 6, flexWrap: 'wrap', alignItems: 'center' }}
+            >
+              <label className="form-label" htmlFor={`qtext-${q.key}`} style={{ marginBottom: 0 }}>
+                Вопрос {qi + 1}
+              </label>
+              <button
+                type="button"
+                className="btn btn-ghost btn--sm"
+                disabled={aiQBusy != null}
+                onClick={() => runAiGenerateQuestion(qi)}
+              >
+                {aiQBusy === qi ? '…' : 'Сгенерировать вопрос (ИИ)'}
+              </button>
+            </div>
+            <p className="text-muted" style={{ marginTop: 0, marginBottom: 6, fontSize: 12 }}>
+              Пустое поле — вопрос и все варианты по числу кнопок; непустое — сформулировать
+              нормальным языком (1–3 предложения).
+            </p>
+            <textarea
+              id={`qtext-${q.key}`}
+              className="form-input"
+              rows={2}
+              value={q.text}
+              onChange={(e) => {
+                const v = e.target.value;
+                setDraftQuestions((prev) =>
+                  prev.map((row, i) => (i === qi ? { ...row, text: v } : row))
+                );
+              }}
+            />
+            <label
+              className="form-label"
+              style={{ display: 'flex', alignItems: 'center', gap: 8, marginTop: 8 }}
+            >
+              <input
+                type="checkbox"
+                checked={q.hasMultipleAnswers}
+                onChange={(e) => {
+                  const v = e.target.checked;
+                  setDraftQuestions((prev) =>
+                    prev.map((row, i) => (i === qi ? { ...row, hasMultipleAnswers: v } : row))
+                  );
+                }}
+              />
+              Несколько верных ответов
+            </label>
+            <p className="muted" style={{ marginBottom: 6, fontSize: 13 }}>
+              Варианты
+            </p>
+            <ul style={{ listStyle: 'none', padding: 0, margin: 0 }}>
+              {q.options.map((o, oi) => (
+                <li
+                  key={o.key}
+                  style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 8, marginBottom: 8 }}
+                >
+                  <input
+                    type="checkbox"
+                    checked={o.isCorrect}
+                    onChange={(e) => {
+                      const v = e.target.checked;
+                      setDraftQuestions((prev) =>
+                        prev.map((row, i) => {
+                          if (i !== qi) {
+                            return row;
+                          }
+                          if (!row.hasMultipleAnswers && v) {
+                            return {
+                              ...row,
+                              options: row.options.map((op, j) => ({
+                                ...op,
+                                isCorrect: j === oi,
+                              })),
+                            };
+                          }
+                          const options = row.options.map((op, j) =>
+                            j === oi ? { ...op, isCorrect: v } : op
+                          );
+                          return { ...row, options };
+                        })
+                      );
+                    }}
+                    title="Верный ответ"
+                    aria-label="Пометить как верный"
+                  />
+                  <input
+                    className="form-input"
+                    style={{ flex: '1 1 200px' }}
+                    value={o.text}
+                    onChange={(e) => {
+                      const v = e.target.value;
+                      setDraftQuestions((prev) =>
+                        prev.map((row, i) => {
+                          if (i !== qi) {
+                            return row;
+                          }
+                          return {
+                            ...row,
+                            options: row.options.map((op, j) => (j === oi ? { ...op, text: v } : op)),
+                          };
+                        })
+                      );
+                    }}
+                    placeholder="Текст варианта"
+                  />
+                  {q.options.length > 1 && (
+                    <button
+                      type="button"
+                      className="btn btn-ghost btn--sm"
+                      onClick={() => removeOption(qi, oi)}
+                    >
+                      убрать
+                    </button>
+                  )}
+                </li>
+              ))}
+            </ul>
+            <div className="inline-actions" style={{ marginTop: 4 }}>
+              <button type="button" className="btn btn-ghost btn--sm" onClick={() => addOption(qi)}>
+                + вариант
+              </button>
+              {draftQuestions.length > 1 && (
+                <button
+                  type="button"
+                  className="btn btn-ghost btn--sm"
+                  onClick={() => removeQuestion(qi)}
+                >
+                  Удалить вопрос
+                </button>
+              )}
+            </div>
+          </div>
+        ))}
+        <div className="inline-actions" style={{ marginTop: '0.75rem' }}>
+          <button type="button" className="btn btn-ghost" onClick={addQuestion}>
+            + вопрос
+          </button>
+          <button type="button" className="btn btn-ghost" onClick={saveDraft}>
+            Сохранить черновик
+          </button>
+        </div>
+        {draftStatus && (
+          <p className="muted" style={{ marginTop: '0.5rem' }}>
+            {draftStatus}
+          </p>
+        )}
       </div>
+      </AccSection>
 
-      <h3 style={{ marginTop: 24 }}>Прохождение (V.4)</h3>
-      <button type="button" onClick={startAttempt}>
-        Старт попытки
-      </button>
+      {assignmentUi && data && (
+        <AccSection title="Назначение сотрудникам" defaultOpen={false}>
+          <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.75rem' }}>
+            Сотрудники из HR; при отсутствии учётки в модуле она создаётся по{' '}
+            <code className="code-inline">staff_id</code>. Источник данных:{' '}
+            <strong>{assignSource === 'hr' ? 'HR (все, с отделами)' : 'только clinic_tests'}</strong>.
+          </p>
+          {assignErr && (
+            <p className="error-text" role="alert">
+              {assignErr}
+            </p>
+          )}
+          <div className="assign-toolbar">
+            <input
+              type="search"
+              className="form-input assign-toolbar__search"
+              placeholder="Поиск: ФИО, логин"
+              value={assignSearch}
+              onChange={(e) => setAssignSearch(e.target.value)}
+              aria-label="Поиск сотрудника"
+            />
+            <select
+              className="form-input"
+              value={assignDept}
+              onChange={(e) => setAssignDept(e.target.value)}
+              aria-label="Фильтр по отделу"
+            >
+              <option value="__all__">Все отделы</option>
+              {assignDepts.map((d) => (
+                <option key={d} value={d}>
+                  {d}
+                </option>
+              ))}
+            </select>
+            <select
+              className="form-input"
+              value={assignClinic}
+              onChange={(e) => setAssignClinic(e.target.value)}
+              aria-label="Кто в модуле"
+            >
+              <option value="all">Все</option>
+              <option value="with">С учёткой в модуле</option>
+              <option value="without">Без учётки (создать)</option>
+            </select>
+            {assignLoadBusy && <span className="text-muted">Загрузка…</span>}
+          </div>
+          <div className="assign-list" role="group" aria-label="Список сотрудников">
+            {assignPeople.length === 0 && !assignLoadBusy && (
+              <p className="text-muted" style={{ margin: '0.5rem 0' }}>
+                Нет подходящих записей. Смените фильтры или поиск.
+              </p>
+            )}
+            {assignPeople.map((p) => {
+              const k = assignPersonKey(p);
+              const picked = assignSelected.has(k);
+              return (
+                <label
+                  key={k}
+                  className={`assign-row${picked ? ' assign-row--selected' : ''}`}
+                >
+                  <input
+                    type="checkbox"
+                    checked={picked}
+                    onChange={() => toggleAssignPerson(p)}
+                  />
+                  <span className="assign-row__text">
+                    <span className="assign-row__fio">{p.fio}</span>
+                    {p.webLogin && (
+                      <span className="assign-row__login">{p.webLogin}</span>
+                    )}
+                    <span className="assign-row__meta">
+                      {p.departments || '—'}
+                      {p.clinicUserId
+                        ? ' · есть учётка в модуле'
+                        : ' · нет учётки (создадим при назначении)'}
+                    </span>
+                  </span>
+                </label>
+              );
+            })}
+          </div>
+          <div className="inline-actions" style={{ marginTop: '0.75rem' }}>
+            <button
+              type="button"
+              className="btn btn-ghost"
+              disabled={assignSelectedInList.length === 0}
+              onClick={postAssign}
+            >
+              Назначить выбранных
+              {assignSelectedInList.length > 0
+                ? ` (${assignSelectedInList.length})`
+                : ''}
+            </button>
+          </div>
+          {assignMsg && <p className="text-muted">{assignMsg}</p>}
+        </AccSection>
+      )}
     </div>
   );
 }
diff --git a/frontend/src/pages/TestsList.jsx b/frontend/src/pages/TestsList.jsx
index 30aeb34..13e8d96 100644
--- a/frontend/src/pages/TestsList.jsx
+++ b/frontend/src/pages/TestsList.jsx
@@ -1,20 +1,27 @@
 import { useEffect, useState } from 'react';
-import { Link, useNavigate } from 'react-router-dom';
+import { Link, useNavigate, useOutletContext } from 'react-router-dom';
 import { api } from '../api';
+import { formatTestAuthorLabel } from '../utils/formatUserName';
 
 export default function TestsList() {
+  const { user, devUi } = useOutletContext() || {};
+  const isEmployee = user?.role === 'employee';
+  const canCreate = devUi || !isEmployee;
   const [tests, setTests] = useState([]);
-  const [user, setUser] = useState(null);
+  const [hiddenByYou, setHiddenByYou] = useState([]);
   const [err, setErr] = useState(null);
   const [title, setTitle] = useState('');
+  const [passBusy, setPassBusy] = useState(null);
+  const [passErr, setPassErr] = useState(null);
   const nav = useNavigate();
 
   async function load() {
+    setErr(null);
+    setPassErr(null);
     try {
-      const me = await api('/api/auth/me');
-      setUser(me.user);
       const t = await api('/api/tests');
       setTests(t.tests || []);
+      setHiddenByYou(t.hiddenByYou || []);
     } catch (e) {
       if (e.status === 401) {
         nav('/login');
@@ -28,6 +35,22 @@ export default function TestsList() {
     load();
   }, [nav]);
 
+  async function startPass(testId) {
+    setPassErr(null);
+    setPassBusy(testId);
+    try {
+      const o = await api(`/api/tests/${testId}/attempts/start`, {
+        method: 'POST',
+        body: JSON.stringify({}),
+      });
+      nav(`/tests/${testId}/attempt/${o.attempt.id}`);
+    } catch (e) {
+      setPassErr(e.message);
+    } finally {
+      setPassBusy(null);
+    }
+  }
+
   async function createTest(e) {
     e.preventDefault();
     if (!title.trim()) {
@@ -45,56 +68,126 @@ export default function TestsList() {
     }
   }
 
-  async function logout() {
-    await api('/api/auth/logout', { method: 'POST' });
-    nav('/login');
-  }
-
   return (
-    <div style={{ maxWidth: 800, margin: '24px auto', fontFamily: 'system-ui' }}>
-      <div style={{ display: 'flex', justifyContent: 'space-between' }}>
-        <h1>Тесты</h1>
-        <div>
-          {user && (
-            <span style={{ marginRight: 12 }}>
-              {user.fullName} ({user.role})
-            </span>
-          )}
-          <button type="button" onClick={logout}>
-            Выйти
-          </button>
-        </div>
-      </div>
-      {err && <p style={{ color: 'coral' }}>{err}</p>}
+    <div>
+      <h1 className="font-headline" style={{ fontSize: '1.5rem' }}>
+        Тесты
+      </h1>
+      {err && (
+        <p className="error-text" role="alert">
+          {err}
+        </p>
+      )}
+      {passErr && (
+        <p className="error-text" role="alert">
+          {passErr}
+        </p>
+      )}
 
-      <form onSubmit={createTest} style={{ margin: '20px 0' }}>
-        <input
-          placeholder="Новый тест — название"
-          value={title}
-          onChange={(e) => setTitle(e.target.value)}
-          style={{ padding: 8, width: 320 }}
-        />
-        <button type="submit" style={{ marginLeft: 8 }}>
-          Создать
-        </button>
-      </form>
+      {canCreate && (
+        <form onSubmit={createTest} className="create-row" aria-label="Создать тест">
+          <input
+            className="form-input"
+            placeholder="Новый тест — название"
+            value={title}
+            onChange={(e) => setTitle(e.target.value)}
+          />
+          <button type="submit" className="btn btn-ghost">
+            Создать
+          </button>
+        </form>
+      )}
 
-      <ul style={{ listStyle: 'none', padding: 0 }}>
+      <ul className="list-stack" aria-label="Тесты в общем списке">
         {tests.map((t) => (
-          <li
-            key={t.id}
-            style={{ border: '1px solid #ddd', marginBottom: 8, padding: 12 }}
-          >
-            <Link to={`/tests/${t.id}`}>
-              {t.title}
-            </Link>
-            <span style={{ color: '#888', fontSize: 13, marginLeft: 8 }}>
-              v{t.version} · активная версия {t.active_version_id?.slice(0, 8)}…
-            </span>
+          <li key={t.id} className="list-row list-row--split">
+            <div className="list-row__main">
+              <Link to={`/tests/${t.id}`} className="list-row__link">
+                <span className="list-row__title">{t.title}</span>
+                <span className="list-row__meta">
+                  {formatTestAuthorLabel(user, t.created_by, t.author_full_name)}
+                  <span className="list-row__meta-sep" aria-hidden>
+                    {' '}
+                    ·{' '}
+                  </span>
+                  v{t.version} · активная {t.active_version_id?.slice(0, 8) ?? '—'}…
+                </span>
+              </Link>
+            </div>
+            <div className="list-row__side">
+              <button
+                type="button"
+                className="btn btn-ghost"
+                disabled={passBusy != null}
+                onClick={() => startPass(t.id)}
+              >
+                {passBusy === t.id ? '…' : 'Пройти'}
+              </button>
+            </div>
           </li>
         ))}
       </ul>
-      {tests.length === 0 && <p>Нет тестов — создайте первый.</p>}
+      {tests.length === 0 && hiddenByYou.length === 0 && (
+        <p className="text-muted">
+          {canCreate
+            ? 'Пусто. В списке — только тесты, которые вы ведёте, и назначенные вам. Создайте цепочку или дождитесь назначения.'
+            : 'Пусто: вам пока ничего не назначено и нет цепочек, где вы автор.'}
+        </p>
+      )}
+      {tests.length === 0 && hiddenByYou.length > 0 && (
+        <p className="text-muted" style={{ marginBottom: '0.75rem' }}>
+          В общем списке пусто — у вас есть скрытые тесты ниже; откройте карточку,
+          чтобы снова включить отображение.
+        </p>
+      )}
+
+      {hiddenByYou.length > 0 && (
+        <>
+          <h2
+            className="font-headline"
+            style={{ fontSize: '1.1rem', marginTop: '1.5rem', marginBottom: '0.5rem' }}
+          >
+            Скрытые вами из списка
+          </h2>
+          <p className="text-muted" style={{ marginTop: 0, marginBottom: '0.75rem' }}>
+            Эти цепочки не видны в блоке выше. Откройте карточку и внизу раздела
+            «Публикация» нажмите «Снова показать в списке».
+          </p>
+          <ul className="list-stack" aria-label="Скрытые тесты автора">
+            {hiddenByYou.map((t) => (
+              <li
+                key={t.id}
+                className="list-row list-row--split"
+                style={{ borderStyle: 'dashed', opacity: 0.95 }}
+              >
+                <div className="list-row__main">
+                  <Link to={`/tests/${t.id}`} className="list-row__link">
+                    <span className="list-row__title">{t.title}</span>
+                    <span className="list-row__meta">
+                      {formatTestAuthorLabel(user, t.created_by, t.author_full_name)}
+                      <span className="list-row__meta-sep" aria-hidden>
+                        {' '}
+                        ·{' '}
+                      </span>
+                      v{t.version} · скрыт · {t.active_version_id?.slice(0, 8) ?? '—'}…
+                    </span>
+                  </Link>
+                </div>
+                <div className="list-row__side">
+                  <button
+                    type="button"
+                    className="btn btn-ghost"
+                    disabled={passBusy != null}
+                    onClick={() => startPass(t.id)}
+                  >
+                    {passBusy === t.id ? '…' : 'Пройти'}
+                  </button>
+                </div>
+              </li>
+            ))}
+          </ul>
+        </>
+      )}
     </div>
   );
 }
diff --git a/frontend/src/utils/formatUserName.js b/frontend/src/utils/formatUserName.js
new file mode 100644
index 0000000..60ab902
--- /dev/null
+++ b/frontend/src/utils/formatUserName.js
@@ -0,0 +1,39 @@
+/**
+ * «Иванов Иван Иванович» → «Иванов И. И.»; «Иванов Иван» → «Иванов И.».
+ * @param {string | null | undefined} fullName
+ * @returns {string}
+ */
+export function formatSurnameWithInitials(fullName) {
+  if (fullName == null || typeof fullName !== 'string') {
+    return '';
+  }
+  const parts = fullName.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) {
+    return '';
+  }
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  const [surname, first, ...rest] = parts;
+  const i1 = first.charAt(0).toLocaleUpperCase('ru-RU');
+  if (parts.length === 2) {
+    return `${surname} ${i1}.`;
+  }
+  const pat = rest.length ? rest[0] : '';
+  const i2 = pat ? pat.charAt(0).toLocaleUpperCase('ru-RU') : '';
+  return i2 ? `${surname} ${i1}. ${i2}.` : `${surname} ${i1}.`;
+}
+
+/**
+ * Подпись автора в списке и карточке.
+ * @param {{ id?: string } | null | undefined} user
+ * @param {string | null | undefined} createdBy
+ * @param {string | null | undefined} authorFullName
+ */
+export function formatTestAuthorLabel(user, createdBy, authorFullName) {
+  if (user?.id != null && createdBy != null && String(user.id) === String(createdBy)) {
+    return 'Автор: Вы';
+  }
+  const short = formatSurnameWithInitials(authorFullName);
+  return short ? `Автор: ${short}` : 'Автор: —';
+}