From bdb266746da800ec4a6dec7adb567e50f5bb281f Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 20:01:28 +0300
Subject: [PATCH 01/25] test set scheduling flow

---
 .../tests/Fakes/FakeScheduleRepository.php    |  97 ++++++
 .../Feature/Schedule/ScheduleEndpointTest.php | 313 +++++++++++++++++
 .../Schedule/UseCases/CreateScheduleTest.php  | 314 ++++++++++++++++++
 3 files changed, 724 insertions(+)
 create mode 100644 backend/tests/Fakes/FakeScheduleRepository.php
 create mode 100644 backend/tests/Feature/Schedule/ScheduleEndpointTest.php
 create mode 100644 backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php

diff --git a/backend/tests/Fakes/FakeScheduleRepository.php b/backend/tests/Fakes/FakeScheduleRepository.php
new file mode 100644
index 0000000..06e281e
--- /dev/null
+++ b/backend/tests/Fakes/FakeScheduleRepository.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Tests\Fakes;
+
+use App\Schedule\CreateScheduleDto;
+use App\Schedule\Schedule;
+use App\Schedule\ScheduleAssignment;
+use App\Schedule\ScheduleRepository;
+use App\User\User;
+
+class FakeScheduleRepository implements ScheduleRepository
+{
+    /**
+     * @var array<int, Schedule>
+     */
+    private array $schedules = [];
+
+    public function create(CreateScheduleDto $dto): Schedule
+    {
+        $id = count($this->schedules) + 1;
+        $assignments = [];
+
+        foreach ($dto->assignments as $assignmentDto) {
+            $assignments[] = new ScheduleAssignment(
+                id: count($assignments) + 1,
+                element: $assignmentDto->element,
+                scheduledDate: $assignmentDto->scheduledDate,
+                position: $assignmentDto->position,
+            );
+        }
+
+        $schedule = new Schedule(
+            id: $id,
+            user: $dto->user,
+            set: $dto->set,
+            elementKind: $dto->elementKind,
+            startDate: $dto->startDate,
+            targetDate: $dto->targetDate,
+            assignments: $assignments,
+        );
+        $this->schedules[$id] = $schedule;
+
+        return $this->copy($schedule);
+    }
+
+    public function findForUser(int $id, User $user): ?Schedule
+    {
+        $schedule = $this->schedules[$id] ?? null;
+        if ($schedule === null || $schedule->getUser()->getId()
+            !== $user->getId()
+        ) {
+            return null;
+        }
+
+        return $this->copy($schedule);
+    }
+
+    public function findAllForUser(User $user): array
+    {
+        $schedules = array_filter(
+            $this->schedules,
+            function (Schedule $schedule) use ($user): bool {
+                return $schedule->getUser()->getId() === $user->getId();
+            },
+        );
+        krsort($schedules);
+
+        return array_map(function (Schedule $schedule): Schedule {
+            return $this->copy($schedule);
+        }, array_values($schedules));
+    }
+
+    private function copy(Schedule $schedule): Schedule
+    {
+        $assignments = array_map(
+            function (ScheduleAssignment $assignment): ScheduleAssignment {
+                return new ScheduleAssignment(
+                    id: $assignment->getId(),
+                    element: $assignment->getElement(),
+                    scheduledDate: $assignment->getScheduledDate(),
+                    position: $assignment->getPosition(),
+                );
+            },
+            $schedule->getAssignments(),
+        );
+
+        return new Schedule(
+            id: $schedule->getId(),
+            user: $schedule->getUser(),
+            set: $schedule->getSet(),
+            elementKind: $schedule->getElementKind(),
+            startDate: $schedule->getStartDate(),
+            targetDate: $schedule->getTargetDate(),
+            assignments: $assignments,
+        );
+    }
+}
diff --git a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
new file mode 100644
index 0000000..731a221
--- /dev/null
+++ b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
@@ -0,0 +1,313 @@
+<?php
+
+namespace Tests\Feature\Schedule;
+
+use App\Auth\CreateSessionDto;
+use App\Auth\SessionRepository;
+use App\Element\CreateElementDto;
+use App\Element\ElementRepository;
+use App\Http\Middleware\AuthMiddleware;
+use App\Set\CreateSetDto;
+use App\Set\Set;
+use App\Set\SetRepository;
+use App\Shared\ValueObject\EmailAddress;
+use App\User\CreateUserDto;
+use App\User\User;
+use App\User\UserRepository;
+use DateTimeImmutable;
+use DateTimeZone;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Testing\TestResponse;
+use Tests\TestCase;
+
+class ScheduleEndpointTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_it_creates_and_returns_a_schedule(): void
+    {
+        $user = $this->createUser('reader@example.com');
+        $creator = $this->createUser('creator@example.com');
+        $set = $this->createSet($creator, 'Bible');
+        $repository = app(ElementRepository::class);
+        $genesis = $repository->create(new CreateElementDto(
+            set: $set,
+            name: 'Genesis',
+            kind: 'book',
+            parentElement: null,
+        ));
+        $creation = $repository->create(new CreateElementDto(
+            set: $set,
+            name: 'Creation',
+            kind: 'portion',
+            parentElement: $genesis,
+        ));
+        $chapterOne = $repository->create(new CreateElementDto(
+            set: $set,
+            name: 'Chapter 1',
+            kind: 'chapter',
+            parentElement: $creation,
+        ));
+        $exodus = $repository->create(new CreateElementDto(
+            set: $set,
+            name: 'Exodus',
+            kind: 'book',
+            parentElement: null,
+        ));
+        $chapterTwo = $repository->create(new CreateElementDto(
+            set: $set,
+            name: 'Chapter 1',
+            kind: 'chapter',
+            parentElement: $exodus,
+        ));
+        $this->createSession($user, 'valid-token');
+
+        $response = $this->credentialedPost('/api/schedules', [
+            'setId' => $set->getId(),
+            'elementKind' => 'chapter',
+            'startDate' => '2026-08-10',
+            'targetDate' => '2026-08-12',
+        ]);
+
+        $response->assertCreated()->assertExactJson([
+            'schedule' => [
+                'id' => 1,
+                'set' => [
+                    'id' => $set->getId(),
+                    'name' => 'Bible',
+                ],
+                'elementKind' => 'chapter',
+                'startDate' => '2026-08-10',
+                'targetDate' => '2026-08-12',
+                'assignmentCount' => 2,
+                'days' => [
+                    [
+                        'date' => '2026-08-10',
+                        'assignments' => [
+                            [
+                                'element' => [
+                                    'id' => $chapterOne->getId(),
+                                    'name' => 'Chapter 1',
+                                    'kind' => 'chapter',
+                                    'path' => [
+                                        'Genesis',
+                                        'Creation',
+                                        'Chapter 1',
+                                    ],
+                                ],
+                            ],
+                        ],
+                    ],
+                    [
+                        'date' => '2026-08-11',
+                        'assignments' => [],
+                    ],
+                    [
+                        'date' => '2026-08-12',
+                        'assignments' => [
+                            [
+                                'element' => [
+                                    'id' => $chapterTwo->getId(),
+                                    'name' => 'Chapter 1',
+                                    'kind' => 'chapter',
+                                    'path' => [
+                                        'Exodus',
+                                        'Chapter 1',
+                                    ],
+                                ],
+                            ],
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+        $this->assertDatabaseHas('schedules', [
+            'user_id' => $user->getId(),
+            'set_id' => $set->getId(),
+            'element_kind' => 'chapter',
+            'start_date' => '2026-08-10',
+            'target_date' => '2026-08-12',
+        ]);
+        $this->assertDatabaseCount('schedule_assignments', 2);
+
+        $this->credentialedGet('/api/schedules/1')
+            ->assertOk()
+            ->assertExactJson($response->json());
+    }
+
+    public function test_it_lists_only_the_users_schedules_newest_first(): void
+    {
+        $user = $this->createUser('reader@example.com');
+        $otherUser = $this->createUser('other@example.com');
+        $set = $this->createSet($user, 'Course');
+        app(ElementRepository::class)->create(new CreateElementDto(
+            set: $set,
+            name: 'Welcome',
+            kind: 'lesson',
+            parentElement: null,
+        ));
+        $this->createSession($user, 'valid-token');
+        $this->createSession($otherUser, 'other-token');
+
+        $this->credentialedPost('/api/schedules', [
+            'setId' => $set->getId(),
+            'elementKind' => 'lesson',
+            'startDate' => '2026-08-01',
+            'targetDate' => '2026-08-01',
+        ])->assertCreated();
+        $this->credentialedPost('/api/schedules', [
+            'setId' => $set->getId(),
+            'elementKind' => 'lesson',
+            'startDate' => '2026-09-01',
+            'targetDate' => '2026-09-01',
+        ])->assertCreated();
+        $this->withCredentials()
+            ->withUnencryptedCookie(
+                AuthMiddleware::COOKIE_NAME,
+                'other-token',
+            )->postJson('/api/schedules', [
+                'setId' => $set->getId(),
+                'elementKind' => 'lesson',
+                'startDate' => '2026-10-01',
+                'targetDate' => '2026-10-01',
+            ])->assertCreated();
+
+        $this->credentialedGet('/api/schedules')
+            ->assertOk()
+            ->assertExactJson([
+                'schedules' => [
+                    [
+                        'id' => 2,
+                        'set' => [
+                            'id' => $set->getId(),
+                            'name' => 'Course',
+                        ],
+                        'elementKind' => 'lesson',
+                        'startDate' => '2026-09-01',
+                        'targetDate' => '2026-09-01',
+                        'assignmentCount' => 1,
+                    ],
+                    [
+                        'id' => 1,
+                        'set' => [
+                            'id' => $set->getId(),
+                            'name' => 'Course',
+                        ],
+                        'elementKind' => 'lesson',
+                        'startDate' => '2026-08-01',
+                        'targetDate' => '2026-08-01',
+                        'assignmentCount' => 1,
+                    ],
+                ],
+            ]);
+    }
+
+    public function test_it_hides_another_users_schedule(): void
+    {
+        $owner = $this->createUser('owner@example.com');
+        $viewer = $this->createUser('viewer@example.com');
+        $set = $this->createSet($owner, 'Course');
+        app(ElementRepository::class)->create(new CreateElementDto(
+            set: $set,
+            name: 'Welcome',
+            kind: 'lesson',
+            parentElement: null,
+        ));
+        $this->createSession($owner, 'owner-token');
+        $this->createSession($viewer, 'viewer-token');
+
+        $this->withCredentials()
+            ->withUnencryptedCookie(
+                AuthMiddleware::COOKIE_NAME,
+                'owner-token',
+            )->postJson('/api/schedules', [
+                'setId' => $set->getId(),
+                'elementKind' => 'lesson',
+                'startDate' => '2026-08-01',
+                'targetDate' => '2026-08-01',
+            ])->assertCreated();
+
+        $this->withCredentials()
+            ->withUnencryptedCookie(
+                AuthMiddleware::COOKIE_NAME,
+                'viewer-token',
+            )->getJson('/api/schedules/1')
+            ->assertNotFound()
+            ->assertExactJson(['error' => 'schedule not found']);
+    }
+
+    public function test_it_rejects_invalid_creation_input(): void
+    {
+        $user = $this->createUser('reader@example.com');
+        $this->createSession($user, 'valid-token');
+
+        $this->credentialedPost('/api/schedules', [
+            'setId' => 999,
+            'elementKind' => 'chapter',
+            'startDate' => '2026-08-12',
+            'targetDate' => '2026-08-10',
+        ])->assertNotFound()->assertExactJson([
+            'error' => 'set not found',
+        ]);
+    }
+
+    public function test_schedule_endpoints_require_authentication(): void
+    {
+        $this->getJson('/api/schedules')->assertStatus(401);
+        $this->getJson('/api/schedules/1')->assertStatus(401);
+        $this->postJson('/api/schedules', [])->assertStatus(401);
+    }
+
+    private function createUser(string $email): User
+    {
+        return app(UserRepository::class)->create(new CreateUserDto(
+            email: new EmailAddress($email),
+            passwordHash: 'hashed-password',
+        ));
+    }
+
+    private function createSet(User $user, string $name): Set
+    {
+        return app(SetRepository::class)->create(new CreateSetDto(
+            name: $name,
+            creator: $user,
+        ));
+    }
+
+    private function createSession(User $user, string $token): void
+    {
+        $createdAt = new DateTimeImmutable(
+            '2026-08-03T12:00:00',
+            new DateTimeZone('UTC'),
+        );
+        app(SessionRepository::class)->create(new CreateSessionDto(
+            token: $token,
+            user: $user,
+            createdAt: $createdAt,
+            expiresAt: $createdAt->modify('+7 days'),
+        ));
+    }
+
+    /**
+     * @param array<string, mixed> $payload
+     */
+    private function credentialedPost(
+        string $uri,
+        array $payload,
+    ): TestResponse {
+        return $this->withCredentials()
+            ->withUnencryptedCookie(
+                AuthMiddleware::COOKIE_NAME,
+                'valid-token',
+            )->postJson($uri, $payload);
+    }
+
+    private function credentialedGet(string $uri): TestResponse
+    {
+        return $this->withCredentials()
+            ->withUnencryptedCookie(
+                AuthMiddleware::COOKIE_NAME,
+                'valid-token',
+            )->getJson($uri);
+    }
+}
diff --git a/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php b/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
new file mode 100644
index 0000000..3814a56
--- /dev/null
+++ b/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
@@ -0,0 +1,314 @@
+<?php
+
+namespace Tests\Unit\Schedule\UseCases;
+
+use App\Element\CreateElementDto;
+use App\Exceptions\BadRequestException;
+use App\Exceptions\NotFoundException;
+use App\Schedule\UseCases\CreateSchedule\CreateSchedule;
+use App\Schedule\UseCases\CreateSchedule\CreateScheduleRequest;
+use App\Set\CreateSetDto;
+use App\Shared\ValueObject\EmailAddress;
+use App\User\User;
+use PHPUnit\Framework\TestCase;
+use Tests\Fakes\FakeElementRepository;
+use Tests\Fakes\FakeScheduleRepository;
+use Tests\Fakes\FakeSetRepository;
+
+class CreateScheduleTest extends TestCase
+{
+    public function test_it_schedules_every_matching_element_in_tree_order(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $elementRepository = new FakeElementRepository;
+        $scheduleRepository = new FakeScheduleRepository;
+        $set = $setRepository->create(new CreateSetDto(
+            name: 'Bible',
+            creator: $user,
+        ));
+        $genesis = $elementRepository->create(new CreateElementDto(
+            set: $set,
+            name: 'Genesis',
+            kind: 'book',
+            parentElement: null,
+        ));
+        $exodus = $elementRepository->create(new CreateElementDto(
+            set: $set,
+            name: 'Exodus',
+            kind: 'book',
+            parentElement: null,
+        ));
+        $exodusChapterOne = $elementRepository->create(
+            new CreateElementDto(
+                set: $set,
+                name: 'Exodus 1',
+                kind: 'chapter',
+                parentElement: $exodus,
+            ),
+        );
+        $creation = $elementRepository->create(new CreateElementDto(
+            set: $set,
+            name: 'Creation',
+            kind: 'portion',
+            parentElement: $genesis,
+        ));
+        $genesisChapterOne = $elementRepository->create(
+            new CreateElementDto(
+                set: $set,
+                name: 'Genesis 1',
+                kind: 'chapter',
+                parentElement: $creation,
+            ),
+        );
+        $genesisChapterTwo = $elementRepository->create(
+            new CreateElementDto(
+                set: $set,
+                name: 'Genesis 2',
+                kind: 'chapter',
+                parentElement: $creation,
+            ),
+        );
+        $genesisChapterThree = $elementRepository->create(
+            new CreateElementDto(
+                set: $set,
+                name: 'Genesis 3',
+                kind: 'chapter',
+                parentElement: $creation,
+            ),
+        );
+        $exodusChapterTwo = $elementRepository->create(
+            new CreateElementDto(
+                set: $set,
+                name: 'Exodus 2',
+                kind: 'chapter',
+                parentElement: $exodus,
+            ),
+        );
+
+        $schedule = (new CreateSchedule(
+            $setRepository,
+            $elementRepository,
+            $scheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $set->getId(),
+            elementKind: 'chapter',
+            startDate: '2026-08-10',
+            targetDate: '2026-08-12',
+        ));
+
+        $this->assertSame('chapter', $schedule->getElementKind());
+        $this->assertSame('2026-08-10', $schedule->getStartDate()->format(
+            'Y-m-d',
+        ));
+        $this->assertSame('2026-08-12', $schedule->getTargetDate()->format(
+            'Y-m-d',
+        ));
+        $this->assertSame(
+            [
+                $genesisChapterOne->getId(),
+                $genesisChapterTwo->getId(),
+                $genesisChapterThree->getId(),
+                $exodusChapterOne->getId(),
+                $exodusChapterTwo->getId(),
+            ],
+            array_map(function ($assignment): int {
+                return $assignment->getElement()->getId();
+            }, $schedule->getAssignments()),
+        );
+        $this->assertSame(
+            [
+                '2026-08-10',
+                '2026-08-10',
+                '2026-08-11',
+                '2026-08-11',
+                '2026-08-12',
+            ],
+            array_map(function ($assignment): string {
+                return $assignment->getScheduledDate()->format('Y-m-d');
+            }, $schedule->getAssignments()),
+        );
+    }
+
+    public function test_it_spreads_sparse_work_across_the_full_range(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $elementRepository = new FakeElementRepository;
+        $set = $setRepository->create(new CreateSetDto(
+            name: 'Course',
+            creator: $user,
+        ));
+
+        foreach (['First', 'Second', 'Third'] as $name) {
+            $elementRepository->create(new CreateElementDto(
+                set: $set,
+                name: $name,
+                kind: 'lesson',
+                parentElement: null,
+            ));
+        }
+
+        $schedule = (new CreateSchedule(
+            $setRepository,
+            $elementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $set->getId(),
+            elementKind: 'lesson',
+            startDate: '2026-08-10',
+            targetDate: '2026-08-16',
+        ));
+
+        $this->assertSame(
+            ['2026-08-10', '2026-08-13', '2026-08-16'],
+            array_map(function ($assignment): string {
+                return $assignment->getScheduledDate()->format('Y-m-d');
+            }, $schedule->getAssignments()),
+        );
+    }
+
+    public function test_it_places_one_element_on_the_start_date(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $elementRepository = new FakeElementRepository;
+        $set = $setRepository->create(new CreateSetDto(
+            name: 'Project',
+            creator: $user,
+        ));
+        $elementRepository->create(new CreateElementDto(
+            set: $set,
+            name: 'Ship it',
+            kind: 'milestone',
+            parentElement: null,
+        ));
+
+        $schedule = (new CreateSchedule(
+            $setRepository,
+            $elementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $set->getId(),
+            elementKind: 'milestone',
+            startDate: '2020-01-01',
+            targetDate: '2030-01-01',
+        ));
+
+        $this->assertSame(
+            '2020-01-01',
+            $schedule->getAssignments()[0]
+                ->getScheduledDate()
+                ->format('Y-m-d'),
+        );
+    }
+
+    public function test_it_rejects_an_unknown_set(): void
+    {
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('set not found');
+
+        (new CreateSchedule(
+            new FakeSetRepository,
+            new FakeElementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $this->user(),
+            setId: 999,
+            elementKind: 'chapter',
+            startDate: '2026-08-10',
+            targetDate: '2026-08-12',
+        ));
+    }
+
+    public function test_it_rejects_an_unavailable_element_kind(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $set = $setRepository->create(new CreateSetDto(
+            name: 'Bible',
+            creator: $user,
+        ));
+
+        $this->expectException(BadRequestException::class);
+        $this->expectExceptionMessage(
+            'elementKind is not available for set',
+        );
+
+        (new CreateSchedule(
+            $setRepository,
+            new FakeElementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $set->getId(),
+            elementKind: 'Chapter',
+            startDate: '2026-08-10',
+            targetDate: '2026-08-12',
+        ));
+    }
+
+    public function test_it_rejects_invalid_dates(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $set = $setRepository->create(new CreateSetDto(
+            name: 'Bible',
+            creator: $user,
+        ));
+
+        $this->expectException(BadRequestException::class);
+        $this->expectExceptionMessage('startDate must be a valid date');
+
+        (new CreateSchedule(
+            $setRepository,
+            new FakeElementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $set->getId(),
+            elementKind: 'chapter',
+            startDate: '2026-02-30',
+            targetDate: '2026-08-12',
+        ));
+    }
+
+    public function test_it_rejects_a_target_before_the_start(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $set = $setRepository->create(new CreateSetDto(
+            name: 'Bible',
+            creator: $user,
+        ));
+
+        $this->expectException(BadRequestException::class);
+        $this->expectExceptionMessage(
+            'targetDate must not be before startDate',
+        );
+
+        (new CreateSchedule(
+            $setRepository,
+            new FakeElementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $set->getId(),
+            elementKind: 'chapter',
+            startDate: '2026-08-12',
+            targetDate: '2026-08-10',
+        ));
+    }
+
+    private function user(): User
+    {
+        return new User(
+            id: 7,
+            email: new EmailAddress('reader@example.com'),
+            passwordHash: 'hashed-password',
+        );
+    }
+}

From 98ae9bf088f60370009b71065df63c69ffa42aa6 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 20:05:53 +0300
Subject: [PATCH 02/25] add set scheduling api

---
 .../Http/Controllers/ScheduleController.php   | 198 ++++++++++++++++
 backend/app/Providers/AppServiceProvider.php  |   6 +
 .../Schedule/CreateScheduleAssignmentDto.php  |  15 ++
 backend/app/Schedule/CreateScheduleDto.php    |  22 ++
 .../Schedule/EloquentScheduleRepository.php   | 115 ++++++++++
 backend/app/Schedule/Schedule.php             |  61 +++++
 backend/app/Schedule/ScheduleAssignment.php   |  36 +++
 .../app/Schedule/ScheduleAssignmentModel.php  |  45 ++++
 backend/app/Schedule/ScheduleModel.php        |  46 ++++
 backend/app/Schedule/ScheduleRepository.php   |  17 ++
 .../CreateSchedule/CreateSchedule.php         | 212 ++++++++++++++++++
 .../CreateSchedule/CreateScheduleRequest.php  |  16 ++
 .../UseCases/GetSchedule/GetSchedule.php      |  30 +++
 .../GetSchedule/GetScheduleRequest.php        |  13 ++
 .../UseCases/ListSchedules/ListSchedules.php  |  22 ++
 backend/app/Shared/Http/RequestInput.php      |   7 +
 ...26_08_10_000000_create_schedules_table.php |  30 +++
 ...0001_create_schedule_assignments_table.php |  38 ++++
 backend/routes/api.php                        |   5 +
 .../Feature/Schedule/ScheduleEndpointTest.php |   2 +-
 20 files changed, 935 insertions(+), 1 deletion(-)
 create mode 100644 backend/app/Http/Controllers/ScheduleController.php
 create mode 100644 backend/app/Schedule/CreateScheduleAssignmentDto.php
 create mode 100644 backend/app/Schedule/CreateScheduleDto.php
 create mode 100644 backend/app/Schedule/EloquentScheduleRepository.php
 create mode 100644 backend/app/Schedule/Schedule.php
 create mode 100644 backend/app/Schedule/ScheduleAssignment.php
 create mode 100644 backend/app/Schedule/ScheduleAssignmentModel.php
 create mode 100644 backend/app/Schedule/ScheduleModel.php
 create mode 100644 backend/app/Schedule/ScheduleRepository.php
 create mode 100644 backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
 create mode 100644 backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php
 create mode 100644 backend/app/Schedule/UseCases/GetSchedule/GetSchedule.php
 create mode 100644 backend/app/Schedule/UseCases/GetSchedule/GetScheduleRequest.php
 create mode 100644 backend/app/Schedule/UseCases/ListSchedules/ListSchedules.php
 create mode 100644 backend/database/migrations/2026_08_10_000000_create_schedules_table.php
 create mode 100644 backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php

diff --git a/backend/app/Http/Controllers/ScheduleController.php b/backend/app/Http/Controllers/ScheduleController.php
new file mode 100644
index 0000000..3ff4a39
--- /dev/null
+++ b/backend/app/Http/Controllers/ScheduleController.php
@@ -0,0 +1,198 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Element\Element;
+use App\Exceptions\BadRequestException;
+use App\Exceptions\NotFoundException;
+use App\Schedule\Schedule;
+use App\Schedule\ScheduleAssignment;
+use App\Schedule\UseCases\CreateSchedule\CreateSchedule;
+use App\Schedule\UseCases\CreateSchedule\CreateScheduleRequest;
+use App\Schedule\UseCases\GetSchedule\GetSchedule;
+use App\Schedule\UseCases\GetSchedule\GetScheduleRequest;
+use App\Schedule\UseCases\ListSchedules\ListSchedules;
+use App\Shared\Http\RequestInput;
+use App\User\User;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class ScheduleController extends Controller
+{
+    public function __construct(
+        private CreateSchedule $createSchedule,
+        private ListSchedules $listSchedules,
+        private GetSchedule $getSchedule,
+    ) {}
+
+    public function store(Request $request): JsonResponse
+    {
+        $input = new RequestInput($request);
+        $user = $this->user($request);
+
+        try {
+            $schedule = $this->createSchedule->execute(
+                new CreateScheduleRequest(
+                    user: $user,
+                    setId: $input->integer('setId'),
+                    elementKind: $input->string('elementKind'),
+                    startDate: $input->string('startDate'),
+                    targetDate: $input->string('targetDate'),
+                ),
+            );
+        } catch (BadRequestException $exception) {
+            return new JsonResponse(
+                ['error' => $exception->getMessage()],
+                400,
+            );
+        } catch (NotFoundException $exception) {
+            return new JsonResponse(
+                ['error' => $exception->getMessage()],
+                404,
+            );
+        }
+
+        return new JsonResponse(
+            ['schedule' => $this->detailPayload($schedule)],
+            201,
+        );
+    }
+
+    public function index(Request $request): JsonResponse
+    {
+        $schedules = array_map(
+            function (Schedule $schedule): array {
+                return $this->summaryPayload($schedule);
+            },
+            $this->listSchedules->execute($this->user($request)),
+        );
+
+        return new JsonResponse(['schedules' => $schedules]);
+    }
+
+    public function show(Request $request, int $scheduleId): JsonResponse
+    {
+        try {
+            $schedule = $this->getSchedule->execute(
+                new GetScheduleRequest(
+                    scheduleId: $scheduleId,
+                    user: $this->user($request),
+                ),
+            );
+        } catch (NotFoundException $exception) {
+            return new JsonResponse(
+                ['error' => $exception->getMessage()],
+                404,
+            );
+        }
+
+        return new JsonResponse([
+            'schedule' => $this->detailPayload($schedule),
+        ]);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function summaryPayload(Schedule $schedule): array
+    {
+        $set = $schedule->getSet();
+
+        return [
+            'id' => $schedule->getId(),
+            'set' => [
+                'id' => $set->getId(),
+                'name' => $set->getName(),
+            ],
+            'elementKind' => $schedule->getElementKind(),
+            'startDate' => $schedule->getStartDate()->format('Y-m-d'),
+            'targetDate' => $schedule->getTargetDate()->format('Y-m-d'),
+            'assignmentCount' => count($schedule->getAssignments()),
+        ];
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function detailPayload(Schedule $schedule): array
+    {
+        $payload = $this->summaryPayload($schedule);
+        $payload['days'] = $this->dayPayloads($schedule);
+
+        return $payload;
+    }
+
+    /**
+     * @return list<array{date: string, assignments: list<mixed>}>
+     */
+    private function dayPayloads(Schedule $schedule): array
+    {
+        $assignmentsByDate = [];
+        foreach ($schedule->getAssignments() as $assignment) {
+            $date = $assignment->getScheduledDate()->format('Y-m-d');
+            $assignmentsByDate[$date][] = $this->assignmentPayload(
+                $assignment,
+            );
+        }
+
+        $days = [];
+        $date = $schedule->getStartDate();
+        while ($date <= $schedule->getTargetDate()) {
+            $formattedDate = $date->format('Y-m-d');
+            $days[] = [
+                'date' => $formattedDate,
+                'assignments' => $assignmentsByDate[$formattedDate] ?? [],
+            ];
+            $date = $date->modify('+1 day');
+        }
+
+        return $days;
+    }
+
+    /**
+     * @return array{element: array{
+     *     id: int,
+     *     name: string,
+     *     kind: string,
+     *     path: list<string>
+     * }}
+     */
+    private function assignmentPayload(
+        ScheduleAssignment $assignment,
+    ): array {
+        $element = $assignment->getElement();
+
+        return [
+            'element' => [
+                'id' => $element->getId(),
+                'name' => $element->getName(),
+                'kind' => $element->getKind(),
+                'path' => $this->elementPath($element),
+            ],
+        ];
+    }
+
+    /**
+     * @return list<string>
+     */
+    private function elementPath(Element $element): array
+    {
+        $path = [];
+        $currentElement = $element;
+
+        while ($currentElement !== null) {
+            array_unshift($path, $currentElement->getName());
+            $currentElement = $currentElement->getParentElement();
+        }
+
+        return $path;
+    }
+
+    private function user(Request $request): User
+    {
+        /** @var User $user */
+        $user = $request->attributes->get('user');
+
+        return $user;
+    }
+}
diff --git a/backend/app/Providers/AppServiceProvider.php b/backend/app/Providers/AppServiceProvider.php
index 8d883fe..d0d019d 100644
--- a/backend/app/Providers/AppServiceProvider.php
+++ b/backend/app/Providers/AppServiceProvider.php
@@ -20,6 +20,8 @@ use App\Element\ElementRepository;
 use App\Element\EloquentElementRepository;
 use App\Set\EloquentSetRepository;
 use App\Set\SetRepository;
+use App\Schedule\EloquentScheduleRepository;
+use App\Schedule\ScheduleRepository;
 use App\User\EloquentUserRepository;
 use App\User\UserRepository;
 use Carbon\CarbonImmutable;
@@ -57,6 +59,10 @@ class AppServiceProvider extends ServiceProvider
             ElementRepository::class,
             EloquentElementRepository::class,
         );
+        $this->app->bind(
+            ScheduleRepository::class,
+            EloquentScheduleRepository::class,
+        );
         $this->app->bind(PasswordHasher::class, BcryptPasswordHasher::class);
         $this->app->bind(TokenGenerator::class, RandomTokenGenerator::class);
         $this->app->bind(Clock::class, SystemClock::class);
diff --git a/backend/app/Schedule/CreateScheduleAssignmentDto.php b/backend/app/Schedule/CreateScheduleAssignmentDto.php
new file mode 100644
index 0000000..682438c
--- /dev/null
+++ b/backend/app/Schedule/CreateScheduleAssignmentDto.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Schedule;
+
+use App\Element\Element;
+use DateTimeImmutable;
+
+final readonly class CreateScheduleAssignmentDto
+{
+    public function __construct(
+        public Element $element,
+        public DateTimeImmutable $scheduledDate,
+        public int $position,
+    ) {}
+}
diff --git a/backend/app/Schedule/CreateScheduleDto.php b/backend/app/Schedule/CreateScheduleDto.php
new file mode 100644
index 0000000..4683bc6
--- /dev/null
+++ b/backend/app/Schedule/CreateScheduleDto.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Schedule;
+
+use App\Set\Set;
+use App\User\User;
+use DateTimeImmutable;
+
+final readonly class CreateScheduleDto
+{
+    /**
+     * @param list<CreateScheduleAssignmentDto> $assignments
+     */
+    public function __construct(
+        public User $user,
+        public Set $set,
+        public string $elementKind,
+        public DateTimeImmutable $startDate,
+        public DateTimeImmutable $targetDate,
+        public array $assignments,
+    ) {}
+}
diff --git a/backend/app/Schedule/EloquentScheduleRepository.php b/backend/app/Schedule/EloquentScheduleRepository.php
new file mode 100644
index 0000000..f23cb30
--- /dev/null
+++ b/backend/app/Schedule/EloquentScheduleRepository.php
@@ -0,0 +1,115 @@
+<?php
+
+namespace App\Schedule;
+
+use App\Element\ElementRepository;
+use App\Set\SetRepository;
+use App\User\User;
+use DateTimeImmutable;
+use DateTimeZone;
+use Illuminate\Support\Facades\DB;
+use RuntimeException;
+
+class EloquentScheduleRepository implements ScheduleRepository
+{
+    public function __construct(
+        private SetRepository $setRepository,
+        private ElementRepository $elementRepository,
+    ) {}
+
+    public function create(CreateScheduleDto $dto): Schedule
+    {
+        return DB::transaction(function () use ($dto): Schedule {
+            $model = ScheduleModel::create([
+                'user_id' => $dto->user->getId(),
+                'set_id' => $dto->set->getId(),
+                'element_kind' => $dto->elementKind,
+                'start_date' => $dto->startDate->format('Y-m-d'),
+                'target_date' => $dto->targetDate->format('Y-m-d'),
+            ]);
+
+            foreach ($dto->assignments as $assignmentDto) {
+                ScheduleAssignmentModel::create([
+                    'schedule_id' => $model->id,
+                    'element_id' => $assignmentDto->element->getId(),
+                    'scheduled_date' => $assignmentDto->scheduledDate
+                        ->format('Y-m-d'),
+                    'position' => $assignmentDto->position,
+                ]);
+            }
+
+            return $this->toDomain($model, $dto->user);
+        });
+    }
+
+    public function findForUser(int $id, User $user): ?Schedule
+    {
+        $model = ScheduleModel::query()
+            ->where('id', $id)
+            ->where('user_id', $user->getId())
+            ->first();
+
+        return $model === null ? null : $this->toDomain($model, $user);
+    }
+
+    public function findAllForUser(User $user): array
+    {
+        $models = ScheduleModel::query()
+            ->where('user_id', $user->getId())
+            ->orderByDesc('id')
+            ->get();
+        $schedules = [];
+
+        foreach ($models as $model) {
+            $schedules[] = $this->toDomain($model, $user);
+        }
+
+        return $schedules;
+    }
+
+    private function toDomain(ScheduleModel $model, User $user): Schedule
+    {
+        $set = $this->setRepository->find($model->set_id);
+        if ($set === null) {
+            throw new RuntimeException('schedule set not found');
+        }
+
+        $assignmentModels = ScheduleAssignmentModel::query()
+            ->where('schedule_id', $model->id)
+            ->orderBy('position')
+            ->orderBy('id')
+            ->get();
+        $assignments = [];
+
+        foreach ($assignmentModels as $assignmentModel) {
+            $element = $this->elementRepository->find(
+                $assignmentModel->element_id,
+            );
+            if ($element === null) {
+                throw new RuntimeException('schedule element not found');
+            }
+
+            $assignments[] = new ScheduleAssignment(
+                id: $assignmentModel->id,
+                element: $element,
+                scheduledDate: $this->date($assignmentModel->scheduled_date),
+                position: $assignmentModel->position,
+            );
+        }
+
+        return new Schedule(
+            id: $model->id,
+            user: $user,
+            set: $set,
+            elementKind: $model->element_kind,
+            startDate: $this->date($model->start_date),
+            targetDate: $this->date($model->target_date),
+            assignments: $assignments,
+        );
+    }
+
+    private function date(string $value): DateTimeImmutable
+    {
+        return new DateTimeImmutable($value, new DateTimeZone('UTC'));
+    }
+}
diff --git a/backend/app/Schedule/Schedule.php b/backend/app/Schedule/Schedule.php
new file mode 100644
index 0000000..ecb3cfa
--- /dev/null
+++ b/backend/app/Schedule/Schedule.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Schedule;
+
+use App\Set\Set;
+use App\User\User;
+use DateTimeImmutable;
+
+final readonly class Schedule
+{
+    /**
+     * @param list<ScheduleAssignment> $assignments
+     */
+    public function __construct(
+        private int $id,
+        private User $user,
+        private Set $set,
+        private string $elementKind,
+        private DateTimeImmutable $startDate,
+        private DateTimeImmutable $targetDate,
+        private array $assignments,
+    ) {}
+
+    public function getId(): int
+    {
+        return $this->id;
+    }
+
+    public function getUser(): User
+    {
+        return $this->user;
+    }
+
+    public function getSet(): Set
+    {
+        return $this->set;
+    }
+
+    public function getElementKind(): string
+    {
+        return $this->elementKind;
+    }
+
+    public function getStartDate(): DateTimeImmutable
+    {
+        return $this->startDate;
+    }
+
+    public function getTargetDate(): DateTimeImmutable
+    {
+        return $this->targetDate;
+    }
+
+    /**
+     * @return list<ScheduleAssignment>
+     */
+    public function getAssignments(): array
+    {
+        return $this->assignments;
+    }
+}
diff --git a/backend/app/Schedule/ScheduleAssignment.php b/backend/app/Schedule/ScheduleAssignment.php
new file mode 100644
index 0000000..97c67a3
--- /dev/null
+++ b/backend/app/Schedule/ScheduleAssignment.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Schedule;
+
+use App\Element\Element;
+use DateTimeImmutable;
+
+final readonly class ScheduleAssignment
+{
+    public function __construct(
+        private int $id,
+        private Element $element,
+        private DateTimeImmutable $scheduledDate,
+        private int $position,
+    ) {}
+
+    public function getId(): int
+    {
+        return $this->id;
+    }
+
+    public function getElement(): Element
+    {
+        return $this->element;
+    }
+
+    public function getScheduledDate(): DateTimeImmutable
+    {
+        return $this->scheduledDate;
+    }
+
+    public function getPosition(): int
+    {
+        return $this->position;
+    }
+}
diff --git a/backend/app/Schedule/ScheduleAssignmentModel.php b/backend/app/Schedule/ScheduleAssignmentModel.php
new file mode 100644
index 0000000..782b906
--- /dev/null
+++ b/backend/app/Schedule/ScheduleAssignmentModel.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Schedule;
+
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+
+/**
+ * @property int $id
+ * @property int $schedule_id
+ * @property int $element_id
+ * @property string $scheduled_date
+ * @property int $position
+ *
+ * @method static Builder<static>|ScheduleAssignmentModel newModelQuery()
+ * @method static Builder<static>|ScheduleAssignmentModel newQuery()
+ * @method static Builder<static>|ScheduleAssignmentModel query()
+ *
+ * @mixin \Eloquent
+ */
+#[Fillable([
+    'schedule_id',
+    'element_id',
+    'scheduled_date',
+    'position',
+])]
+class ScheduleAssignmentModel extends Model
+{
+    protected $table = 'schedule_assignments';
+
+    public $timestamps = false;
+
+    /**
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'schedule_id' => 'integer',
+            'element_id' => 'integer',
+            'position' => 'integer',
+        ];
+    }
+}
diff --git a/backend/app/Schedule/ScheduleModel.php b/backend/app/Schedule/ScheduleModel.php
new file mode 100644
index 0000000..6d0132d
--- /dev/null
+++ b/backend/app/Schedule/ScheduleModel.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Schedule;
+
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+
+/**
+ * @property int $id
+ * @property int $user_id
+ * @property int $set_id
+ * @property string $element_kind
+ * @property string $start_date
+ * @property string $target_date
+ *
+ * @method static Builder<static>|ScheduleModel newModelQuery()
+ * @method static Builder<static>|ScheduleModel newQuery()
+ * @method static Builder<static>|ScheduleModel query()
+ *
+ * @mixin \Eloquent
+ */
+#[Fillable([
+    'user_id',
+    'set_id',
+    'element_kind',
+    'start_date',
+    'target_date',
+])]
+class ScheduleModel extends Model
+{
+    protected $table = 'schedules';
+
+    public $timestamps = false;
+
+    /**
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'user_id' => 'integer',
+            'set_id' => 'integer',
+        ];
+    }
+}
diff --git a/backend/app/Schedule/ScheduleRepository.php b/backend/app/Schedule/ScheduleRepository.php
new file mode 100644
index 0000000..bd02515
--- /dev/null
+++ b/backend/app/Schedule/ScheduleRepository.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Schedule;
+
+use App\User\User;
+
+interface ScheduleRepository
+{
+    public function create(CreateScheduleDto $dto): Schedule;
+
+    public function findForUser(int $id, User $user): ?Schedule;
+
+    /**
+     * @return list<Schedule>
+     */
+    public function findAllForUser(User $user): array;
+}
diff --git a/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php b/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
new file mode 100644
index 0000000..c41b19c
--- /dev/null
+++ b/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
@@ -0,0 +1,212 @@
+<?php
+
+namespace App\Schedule\UseCases\CreateSchedule;
+
+use App\Element\Element;
+use App\Element\ElementRepository;
+use App\Exceptions\BadRequestException;
+use App\Exceptions\NotFoundException;
+use App\Schedule\CreateScheduleAssignmentDto;
+use App\Schedule\CreateScheduleDto;
+use App\Schedule\Schedule;
+use App\Schedule\ScheduleRepository;
+use App\Set\Set;
+use App\Set\SetRepository;
+use DateTimeImmutable;
+use DateTimeZone;
+
+class CreateSchedule
+{
+    public function __construct(
+        private SetRepository $setRepository,
+        private ElementRepository $elementRepository,
+        private ScheduleRepository $scheduleRepository,
+    ) {}
+
+    /**
+     * @throws BadRequestException
+     * @throws NotFoundException
+     */
+    public function execute(CreateScheduleRequest $request): Schedule
+    {
+        if ($request->setId === null || $request->setId < 1) {
+            throw new BadRequestException('setId is required');
+        }
+
+        $set = $this->setRepository->find($request->setId);
+        if ($set === null) {
+            throw new NotFoundException('set not found');
+        }
+
+        if ($request->elementKind === null || $request->elementKind === '') {
+            throw new BadRequestException('elementKind is required');
+        }
+
+        $startDate = $this->parseDate($request->startDate, 'startDate');
+        $targetDate = $this->parseDate($request->targetDate, 'targetDate');
+        if ($targetDate < $startDate) {
+            throw new BadRequestException(
+                'targetDate must not be before startDate',
+            );
+        }
+
+        $elements = array_values(array_filter(
+            $this->orderedElements($set),
+            function (Element $element) use ($request): bool {
+                return $element->getKind() === $request->elementKind;
+            },
+        ));
+        if ($elements === []) {
+            throw new BadRequestException(
+                'elementKind is not available for set',
+            );
+        }
+
+        $assignments = $this->assignments(
+            elements: $elements,
+            startDate: $startDate,
+            targetDate: $targetDate,
+        );
+
+        return $this->scheduleRepository->create(new CreateScheduleDto(
+            user: $request->user,
+            set: $set,
+            elementKind: $request->elementKind,
+            startDate: $startDate,
+            targetDate: $targetDate,
+            assignments: $assignments,
+        ));
+    }
+
+    /**
+     * @return list<Element>
+     */
+    private function orderedElements(Set $set): array
+    {
+        $childrenByParentId = [];
+
+        foreach ($this->elementRepository->findBySet($set) as $element) {
+            $parentId = $element->getParentElement()?->getId() ?? 0;
+            $childrenByParentId[$parentId][] = $element;
+        }
+
+        foreach ($childrenByParentId as &$children) {
+            usort($children, function (Element $first, Element $second): int {
+                $positionComparison = $first->getPosition()
+                    <=> $second->getPosition();
+                if ($positionComparison !== 0) {
+                    return $positionComparison;
+                }
+
+                return $first->getId() <=> $second->getId();
+            });
+        }
+        unset($children);
+
+        $orderedElements = [];
+        $this->appendChildren(
+            parentId: 0,
+            childrenByParentId: $childrenByParentId,
+            orderedElements: $orderedElements,
+        );
+
+        return $orderedElements;
+    }
+
+    /**
+     * @param array<int, list<Element>> $childrenByParentId
+     * @param list<Element> $orderedElements
+     */
+    private function appendChildren(
+        int $parentId,
+        array $childrenByParentId,
+        array &$orderedElements,
+    ): void {
+        foreach ($childrenByParentId[$parentId] ?? [] as $element) {
+            $orderedElements[] = $element;
+            $this->appendChildren(
+                parentId: $element->getId(),
+                childrenByParentId: $childrenByParentId,
+                orderedElements: $orderedElements,
+            );
+        }
+    }
+
+    /**
+     * @param list<Element> $elements
+     * @return list<CreateScheduleAssignmentDto>
+     */
+    private function assignments(
+        array $elements,
+        DateTimeImmutable $startDate,
+        DateTimeImmutable $targetDate,
+    ): array {
+        $differenceInDays = $startDate->diff($targetDate)->days;
+        $dayCount = $differenceInDays + 1;
+        $elementCount = count($elements);
+        $assignments = [];
+
+        foreach ($elements as $index => $element) {
+            $dayIndex = $this->dayIndex(
+                elementIndex: $index,
+                elementCount: $elementCount,
+                dayCount: $dayCount,
+            );
+            $assignments[] = new CreateScheduleAssignmentDto(
+                element: $element,
+                scheduledDate: $startDate->modify("+{$dayIndex} days"),
+                position: $index + 1,
+            );
+        }
+
+        return $assignments;
+    }
+
+    private function dayIndex(
+        int $elementIndex,
+        int $elementCount,
+        int $dayCount,
+    ): int {
+        if ($elementCount === 1 || $dayCount === 1) {
+            return 0;
+        }
+
+        if ($elementCount < $dayCount) {
+            $scaledIndex = $elementIndex * ($dayCount - 1)
+                / ($elementCount - 1);
+
+            return (int) floor($scaledIndex + 0.5);
+        }
+
+        return intdiv($elementIndex * $dayCount, $elementCount);
+    }
+
+    /**
+     * @throws BadRequestException
+     */
+    private function parseDate(?string $value, string $field): DateTimeImmutable
+    {
+        if ($value === null || $value === '') {
+            throw new BadRequestException("{$field} is required");
+        }
+
+        $date = DateTimeImmutable::createFromFormat(
+            '!Y-m-d',
+            $value,
+            new DateTimeZone('UTC'),
+        );
+        $errors = DateTimeImmutable::getLastErrors();
+        if (
+            $date === false
+            || $date->format('Y-m-d') !== $value
+            || ($errors !== false
+                && ($errors['warning_count'] > 0 || $errors['error_count'] > 0))
+        ) {
+            throw new BadRequestException(
+                "{$field} must be a valid date in YYYY-MM-DD format",
+            );
+        }
+
+        return $date;
+    }
+}
diff --git a/backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php b/backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php
new file mode 100644
index 0000000..d75ab71
--- /dev/null
+++ b/backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Schedule\UseCases\CreateSchedule;
+
+use App\User\User;
+
+final readonly class CreateScheduleRequest
+{
+    public function __construct(
+        public User $user,
+        public ?int $setId,
+        public ?string $elementKind,
+        public ?string $startDate,
+        public ?string $targetDate,
+    ) {}
+}
diff --git a/backend/app/Schedule/UseCases/GetSchedule/GetSchedule.php b/backend/app/Schedule/UseCases/GetSchedule/GetSchedule.php
new file mode 100644
index 0000000..447d655
--- /dev/null
+++ b/backend/app/Schedule/UseCases/GetSchedule/GetSchedule.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Schedule\UseCases\GetSchedule;
+
+use App\Exceptions\NotFoundException;
+use App\Schedule\Schedule;
+use App\Schedule\ScheduleRepository;
+
+class GetSchedule
+{
+    public function __construct(
+        private ScheduleRepository $scheduleRepository,
+    ) {}
+
+    /**
+     * @throws NotFoundException
+     */
+    public function execute(GetScheduleRequest $request): Schedule
+    {
+        $schedule = $this->scheduleRepository->findForUser(
+            $request->scheduleId,
+            $request->user,
+        );
+        if ($schedule === null) {
+            throw new NotFoundException('schedule not found');
+        }
+
+        return $schedule;
+    }
+}
diff --git a/backend/app/Schedule/UseCases/GetSchedule/GetScheduleRequest.php b/backend/app/Schedule/UseCases/GetSchedule/GetScheduleRequest.php
new file mode 100644
index 0000000..c737d1e
--- /dev/null
+++ b/backend/app/Schedule/UseCases/GetSchedule/GetScheduleRequest.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Schedule\UseCases\GetSchedule;
+
+use App\User\User;
+
+final readonly class GetScheduleRequest
+{
+    public function __construct(
+        public int $scheduleId,
+        public User $user,
+    ) {}
+}
diff --git a/backend/app/Schedule/UseCases/ListSchedules/ListSchedules.php b/backend/app/Schedule/UseCases/ListSchedules/ListSchedules.php
new file mode 100644
index 0000000..750cbfd
--- /dev/null
+++ b/backend/app/Schedule/UseCases/ListSchedules/ListSchedules.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Schedule\UseCases\ListSchedules;
+
+use App\Schedule\Schedule;
+use App\Schedule\ScheduleRepository;
+use App\User\User;
+
+class ListSchedules
+{
+    public function __construct(
+        private ScheduleRepository $scheduleRepository,
+    ) {}
+
+    /**
+     * @return list<Schedule>
+     */
+    public function execute(User $user): array
+    {
+        return $this->scheduleRepository->findAllForUser($user);
+    }
+}
diff --git a/backend/app/Shared/Http/RequestInput.php b/backend/app/Shared/Http/RequestInput.php
index 6dffb92..322817a 100644
--- a/backend/app/Shared/Http/RequestInput.php
+++ b/backend/app/Shared/Http/RequestInput.php
@@ -20,4 +20,11 @@ class RequestInput
 
         return null;
     }
+
+    public function integer(string $key): ?int
+    {
+        $value = $this->request->input($key);
+
+        return is_int($value) ? $value : null;
+    }
 }
diff --git a/backend/database/migrations/2026_08_10_000000_create_schedules_table.php b/backend/database/migrations/2026_08_10_000000_create_schedules_table.php
new file mode 100644
index 0000000..cfe3028
--- /dev/null
+++ b/backend/database/migrations/2026_08_10_000000_create_schedules_table.php
@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('schedules', function (Blueprint $table): void {
+            $table->id();
+            $table->foreignId('user_id')
+                ->constrained('users')
+                ->restrictOnDelete();
+            $table->foreignId('set_id')
+                ->constrained('sets')
+                ->restrictOnDelete();
+            $table->string('element_kind');
+            $table->date('start_date');
+            $table->date('target_date');
+            $table->index(['user_id', 'id']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('schedules');
+    }
+};
diff --git a/backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php b/backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php
new file mode 100644
index 0000000..88c05b3
--- /dev/null
+++ b/backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php
@@ -0,0 +1,38 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create(
+            'schedule_assignments',
+            function (Blueprint $table): void {
+                $table->id();
+                $table->foreignId('schedule_id')
+                    ->constrained('schedules')
+                    ->cascadeOnDelete();
+                $table->foreignId('element_id')
+                    ->constrained('elements')
+                    ->restrictOnDelete();
+                $table->date('scheduled_date');
+                $table->unsignedInteger('position');
+                $table->unique(['schedule_id', 'element_id']);
+                $table->unique(['schedule_id', 'position']);
+                $table->index([
+                    'schedule_id',
+                    'scheduled_date',
+                    'position',
+                ]);
+            },
+        );
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('schedule_assignments');
+    }
+};
diff --git a/backend/routes/api.php b/backend/routes/api.php
index 9b70efe..7f984c5 100644
--- a/backend/routes/api.php
+++ b/backend/routes/api.php
@@ -2,6 +2,7 @@
 
 use App\Http\Controllers\AuthController;
 use App\Http\Controllers\SetController;
+use App\Http\Controllers\ScheduleController;
 use App\Http\Middleware\AuthMiddleware;
 use Illuminate\Support\Facades\Route;
 
@@ -14,5 +15,9 @@ Route::middleware(AuthMiddleware::class)->group(function (): void {
     Route::get('/sets', [SetController::class, 'index']);
     Route::get('/sets/{setId}', [SetController::class, 'show'])
         ->whereNumber('setId');
+    Route::post('/schedules', [ScheduleController::class, 'store']);
+    Route::get('/schedules', [ScheduleController::class, 'index']);
+    Route::get('/schedules/{scheduleId}', [ScheduleController::class, 'show'])
+        ->whereNumber('scheduleId');
     Route::post('/logout', [AuthController::class, 'logout']);
 });
diff --git a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
index 731a221..6b9a679 100644
--- a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
+++ b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
@@ -284,7 +284,7 @@ class ScheduleEndpointTest extends TestCase
             token: $token,
             user: $user,
             createdAt: $createdAt,
-            expiresAt: $createdAt->modify('+7 days'),
+            expiresAt: $createdAt->modify('+10 years'),
         ));
     }
 

From b812a4b21b6acbe7ab8b4ed11c6f01c768474f27 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 20:06:15 +0300
Subject: [PATCH 03/25] stabilize set endpoint sessions

---
 backend/tests/Feature/Set/GetSetLayoutEndpointTest.php | 2 +-
 backend/tests/Feature/Set/ListSetsEndpointTest.php     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php b/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php
index 074f7f5..3a71638 100644
--- a/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php
+++ b/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php
@@ -157,7 +157,7 @@ class GetSetLayoutEndpointTest extends TestCase
             token: 'valid-token',
             user: $user,
             createdAt: $createdAt,
-            expiresAt: $createdAt->modify('+7 days'),
+            expiresAt: $createdAt->modify('+10 years'),
         ));
     }
 
diff --git a/backend/tests/Feature/Set/ListSetsEndpointTest.php b/backend/tests/Feature/Set/ListSetsEndpointTest.php
index 6f8085b..e37c464 100644
--- a/backend/tests/Feature/Set/ListSetsEndpointTest.php
+++ b/backend/tests/Feature/Set/ListSetsEndpointTest.php
@@ -96,7 +96,7 @@ class ListSetsEndpointTest extends TestCase
             token: 'valid-token',
             user: $user,
             createdAt: $createdAt,
-            expiresAt: $createdAt->modify('+7 days'),
+            expiresAt: $createdAt->modify('+10 years'),
         ));
     }
 }

From b7fb594c264cff020acc6357e17e7c03fd0ffe0a Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 20:11:09 +0300
Subject: [PATCH 04/25] test set scheduling ui

---
 .../website/cypress/e2e/confirm-email.cy.ts   |   4 +
 frontend/website/cypress/e2e/guest-auth.cy.ts |   8 +
 .../website/cypress/e2e/session-auth.cy.ts    |   4 +
 .../website/cypress/e2e/set-scheduling.cy.ts  | 242 ++++++++++++++++++
 .../website/cypress/e2e/sets-dashboard.cy.ts  |   4 +
 5 files changed, 262 insertions(+)
 create mode 100644 frontend/website/cypress/e2e/set-scheduling.cy.ts

diff --git a/frontend/website/cypress/e2e/confirm-email.cy.ts b/frontend/website/cypress/e2e/confirm-email.cy.ts
index deabca6..2ef0274 100644
--- a/frontend/website/cypress/e2e/confirm-email.cy.ts
+++ b/frontend/website/cypress/e2e/confirm-email.cy.ts
@@ -13,6 +13,10 @@ describe('email confirmation', () => {
       statusCode: 200,
       body: { sets: [] },
     })
+    cy.intercept('GET', '**/api/schedules', {
+      statusCode: 200,
+      body: { schedules: [] },
+    })
   })
 
   it('chooses a password, confirms the account, and opens the dashboard', () => {
diff --git a/frontend/website/cypress/e2e/guest-auth.cy.ts b/frontend/website/cypress/e2e/guest-auth.cy.ts
index 75c441c..00d0d19 100644
--- a/frontend/website/cypress/e2e/guest-auth.cy.ts
+++ b/frontend/website/cypress/e2e/guest-auth.cy.ts
@@ -31,6 +31,14 @@ describe('guest authentication pages', () => {
     cy.location('search').should('include', 'redirect=/sets/41')
   })
 
+  it('redirects guests away from protected schedule routes', () => {
+    cy.visit('/sets/41/schedules/new')
+    cy.location('pathname').should('equal', '/login')
+
+    cy.visit('/schedules/73')
+    cy.location('pathname').should('equal', '/login')
+  })
+
   it('shows the login form and links to signup', () => {
     cy.visit('/login')
 
diff --git a/frontend/website/cypress/e2e/session-auth.cy.ts b/frontend/website/cypress/e2e/session-auth.cy.ts
index defb942..eb88490 100644
--- a/frontend/website/cypress/e2e/session-auth.cy.ts
+++ b/frontend/website/cypress/e2e/session-auth.cy.ts
@@ -43,6 +43,10 @@ describe('session authentication', () => {
       statusCode: 200,
       body: { sets: [] },
     })
+    cy.intercept('GET', '**/api/schedules', {
+      statusCode: 200,
+      body: { schedules: [] },
+    })
   })
 
   it('restores an authenticated session on a protected route', () => {
diff --git a/frontend/website/cypress/e2e/set-scheduling.cy.ts b/frontend/website/cypress/e2e/set-scheduling.cy.ts
new file mode 100644
index 0000000..7967845
--- /dev/null
+++ b/frontend/website/cypress/e2e/set-scheduling.cy.ts
@@ -0,0 +1,242 @@
+const authenticatedUser = {
+  id: 7,
+  email: 'user@example.com',
+}
+
+const bibleLayout = {
+  set: { id: 41, name: 'Bible' },
+  elements: [
+    {
+      id: 1,
+      name: 'Genesis',
+      kind: 'book',
+      children: [
+        {
+          id: 3,
+          name: 'Creation',
+          kind: 'portion',
+          children: [
+            {
+              id: 4,
+              name: 'Chapter 1',
+              kind: 'chapter',
+              children: [],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      id: 2,
+      name: 'Exodus',
+      kind: 'book',
+      children: [
+        {
+          id: 5,
+          name: 'Chapter 1',
+          kind: 'chapter',
+          children: [],
+        },
+      ],
+    },
+  ],
+}
+
+const scheduleDetail = {
+  schedule: {
+    id: 73,
+    set: { id: 41, name: 'Bible' },
+    elementKind: 'chapter',
+    startDate: '2026-08-10',
+    targetDate: '2026-08-12',
+    assignmentCount: 2,
+    days: [
+      {
+        date: '2026-08-10',
+        assignments: [
+          {
+            element: {
+              id: 4,
+              name: 'Chapter 1',
+              kind: 'chapter',
+              path: ['Genesis', 'Creation', 'Chapter 1'],
+            },
+          },
+        ],
+      },
+      { date: '2026-08-11', assignments: [] },
+      {
+        date: '2026-08-12',
+        assignments: [
+          {
+            element: {
+              id: 5,
+              name: 'Chapter 1',
+              kind: 'chapter',
+              path: ['Exodus', 'Chapter 1'],
+            },
+          },
+        ],
+      },
+    ],
+  },
+}
+
+function interceptAuthenticatedUser(): void {
+  cy.intercept('GET', '**/api/me', {
+    statusCode: 200,
+    body: { user: authenticatedUser },
+  }).as('me')
+}
+
+describe('set scheduling', () => {
+  beforeEach(() => {
+    interceptAuthenticatedUser()
+  })
+
+  it('creates a schedule from a set and shows every day', () => {
+    cy.intercept('GET', '**/api/sets/41', {
+      statusCode: 200,
+      body: bibleLayout,
+    }).as('layout')
+    cy.intercept('POST', '**/api/schedules', (request) => {
+      expect(request.headers.accept).to.equal('application/json')
+      expect(request.body).to.deep.equal({
+        setId: 41,
+        elementKind: 'chapter',
+        startDate: '2026-08-10',
+        targetDate: '2026-08-12',
+      })
+      request.reply({ statusCode: 201, body: scheduleDetail })
+    }).as('createSchedule')
+
+    cy.visit('/sets/41')
+    cy.wait('@me')
+    cy.wait('@layout')
+    cy.contains('a', 'Schedule this set')
+      .should('have.attr', 'href', '/sets/41/schedules/new')
+      .click()
+
+    cy.location('pathname').should('equal', '/sets/41/schedules/new')
+    cy.get('h1').should('have.text', 'Schedule Bible')
+    cy.get('#schedule-level option').then(($options) => {
+      expect([...$options].map((option) => option.textContent)).to.deep.equal([
+        'Choose a level',
+        'Book (2)',
+        'Portion (1)',
+        'Chapter (2)',
+      ])
+    })
+    cy.get('#schedule-level').select('chapter')
+    cy.get('#schedule-start-date').type('2026-08-10')
+    cy.get('#schedule-target-date').type('2026-08-12')
+    cy.get('form').submit()
+    cy.wait('@createSchedule')
+
+    cy.location('pathname').should('equal', '/schedules/73')
+    cy.get('h1').should('have.text', 'Bible schedule')
+    cy.get('[data-schedule-day]').should('have.length', 3)
+    cy.get('[data-schedule-date="2026-08-10"]')
+      .should('contain.text', 'Genesis / Creation / Chapter 1')
+      .and('contain.text', 'Chapter')
+    cy.get('[data-schedule-date="2026-08-11"]')
+      .should('contain.text', 'Rest day')
+      .and('not.contain.text', 'Chapter 1')
+    cy.get('[data-schedule-date="2026-08-12"]').should(
+      'contain.text',
+      'Exodus / Chapter 1',
+    )
+  })
+
+  it('validates the schedule form before submitting', () => {
+    cy.intercept('GET', '**/api/sets/41', {
+      statusCode: 200,
+      body: bibleLayout,
+    }).as('layout')
+    cy.intercept('POST', '**/api/schedules').as('createSchedule')
+
+    cy.visit('/sets/41/schedules/new')
+    cy.wait('@me')
+    cy.wait('@layout')
+    cy.get('form').submit()
+
+    cy.get('#schedule-level-error')
+      .should('have.text', 'Choose a level to schedule.')
+      .and('be.visible')
+    cy.get('#schedule-start-date-error')
+      .should('have.text', 'Choose a start date.')
+      .and('be.visible')
+    cy.get('#schedule-target-date-error')
+      .should('have.text', 'Choose a target date.')
+      .and('be.visible')
+    cy.get('@createSchedule.all').should('have.length', 0)
+
+    cy.get('#schedule-level').select('chapter')
+    cy.get('#schedule-start-date').type('2026-08-12')
+    cy.get('#schedule-target-date').type('2026-08-10')
+    cy.get('form').submit()
+    cy.get('#schedule-target-date-error').should(
+      'have.text',
+      'Target date cannot be before the start date.',
+    )
+    cy.get('@createSchedule.all').should('have.length', 0)
+  })
+
+  it('loads a persisted schedule directly and handles missing schedules', () => {
+    cy.intercept('GET', '**/api/schedules/73', {
+      statusCode: 200,
+      body: scheduleDetail,
+    }).as('schedule')
+
+    cy.visit('/schedules/73')
+    cy.wait('@me')
+    cy.wait('@schedule')
+    cy.get('h1').should('have.text', 'Bible schedule')
+    cy.contains('2 chapters across 3 days').should('be.visible')
+
+    cy.intercept('GET', '**/api/schedules/74', {
+      statusCode: 404,
+      body: { error: 'schedule not found' },
+    }).as('missingSchedule')
+    cy.visit('/schedules/74')
+    cy.wait('@missingSchedule')
+    cy.get('h1').should('have.text', 'Schedule not found')
+  })
+
+  it('lists the users schedules on the dashboard', () => {
+    cy.intercept('GET', '**/api/sets', {
+      statusCode: 200,
+      body: { sets: [] },
+    }).as('sets')
+    cy.intercept('GET', '**/api/schedules', (request) => {
+      expect(request.headers.accept).to.equal('application/json')
+      request.reply({
+        statusCode: 200,
+        body: {
+          schedules: [
+            {
+              id: 73,
+              set: { id: 41, name: 'Bible' },
+              elementKind: 'chapter',
+              startDate: '2026-08-10',
+              targetDate: '2026-08-12',
+              assignmentCount: 2,
+            },
+          ],
+        },
+      })
+    }).as('schedules')
+
+    cy.visit('/dashboard')
+    cy.wait('@me')
+    cy.wait('@sets')
+    cy.wait('@schedules')
+
+    cy.get('#schedules-heading').should('have.text', 'Your schedules')
+    cy.get('ul[aria-label="Your schedules"]')
+      .should('contain.text', 'Bible')
+      .and('contain.text', 'Chapter')
+      .and('contain.text', '2 assignments')
+    cy.contains('a', 'Bible').should('have.attr', 'href', '/schedules/73')
+  })
+})
diff --git a/frontend/website/cypress/e2e/sets-dashboard.cy.ts b/frontend/website/cypress/e2e/sets-dashboard.cy.ts
index 4b6fc2d..6cff9ed 100644
--- a/frontend/website/cypress/e2e/sets-dashboard.cy.ts
+++ b/frontend/website/cypress/e2e/sets-dashboard.cy.ts
@@ -13,6 +13,10 @@ function interceptAuthenticatedUser(): void {
 describe('sets dashboard', () => {
   beforeEach(() => {
     interceptAuthenticatedUser()
+    cy.intercept('GET', '**/api/schedules', {
+      statusCode: 200,
+      body: { schedules: [] },
+    })
   })
 
   it('shows every available set as a detail link', () => {

From 7e9e93f8d0ceca31757c7f9cdd256d6024c8c86b Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 20:16:44 +0300
Subject: [PATCH 05/25] add set scheduling ui

---
 .../website/cypress/e2e/set-scheduling.cy.ts  |   9 +-
 frontend/website/src/router/index.ts          |  16 +
 frontend/website/src/stores/schedules.ts      | 220 ++++++++++
 frontend/website/src/styles/main.css          |   3 +-
 .../website/src/views/CreateScheduleView.vue  | 405 ++++++++++++++++++
 frontend/website/src/views/DashboardView.vue  | 181 +++++++-
 .../website/src/views/ScheduleDetailView.vue  | 323 ++++++++++++++
 frontend/website/src/views/SetLayoutView.vue  |  33 ++
 8 files changed, 1182 insertions(+), 8 deletions(-)
 create mode 100644 frontend/website/src/stores/schedules.ts
 create mode 100644 frontend/website/src/views/CreateScheduleView.vue
 create mode 100644 frontend/website/src/views/ScheduleDetailView.vue

diff --git a/frontend/website/cypress/e2e/set-scheduling.cy.ts b/frontend/website/cypress/e2e/set-scheduling.cy.ts
index 7967845..824024d 100644
--- a/frontend/website/cypress/e2e/set-scheduling.cy.ts
+++ b/frontend/website/cypress/e2e/set-scheduling.cy.ts
@@ -120,12 +120,9 @@ describe('set scheduling', () => {
     cy.location('pathname').should('equal', '/sets/41/schedules/new')
     cy.get('h1').should('have.text', 'Schedule Bible')
     cy.get('#schedule-level option').then(($options) => {
-      expect([...$options].map((option) => option.textContent)).to.deep.equal([
-        'Choose a level',
-        'Book (2)',
-        'Portion (1)',
-        'Chapter (2)',
-      ])
+      expect([...$options].map((option) => option.textContent?.trim())).to.deep.equal(
+        ['Choose a level', 'Book (2)', 'Portion (1)', 'Chapter (2)'],
+      )
     })
     cy.get('#schedule-level').select('chapter')
     cy.get('#schedule-start-date').type('2026-08-10')
diff --git a/frontend/website/src/router/index.ts b/frontend/website/src/router/index.ts
index 08f1ad0..d4fad22 100644
--- a/frontend/website/src/router/index.ts
+++ b/frontend/website/src/router/index.ts
@@ -71,6 +71,22 @@ const router = createRouter({
         requiresAuth: true,
       },
     },
+    {
+      path: '/sets/:setId(\\d+)/schedules/new',
+      name: 'schedule-create',
+      component: () => import('@/views/CreateScheduleView.vue'),
+      meta: {
+        requiresAuth: true,
+      },
+    },
+    {
+      path: '/schedules/:scheduleId(\\d+)',
+      name: 'schedule-detail',
+      component: () => import('@/views/ScheduleDetailView.vue'),
+      meta: {
+        requiresAuth: true,
+      },
+    },
   ],
 })
 
diff --git a/frontend/website/src/stores/schedules.ts b/frontend/website/src/stores/schedules.ts
new file mode 100644
index 0000000..79f27a1
--- /dev/null
+++ b/frontend/website/src/stores/schedules.ts
@@ -0,0 +1,220 @@
+import { ref } from 'vue'
+import { defineStore } from 'pinia'
+import { z } from 'zod'
+
+import { API_BASE } from '@/utils/apiBase'
+
+const isoDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/)
+
+export const scheduleSummarySchema = z.object({
+  id: z.number().int().positive(),
+  set: z.object({
+    id: z.number().int().positive(),
+    name: z.string().min(1),
+  }),
+  elementKind: z.string().min(1),
+  startDate: isoDateSchema,
+  targetDate: isoDateSchema,
+  assignmentCount: z.number().int().nonnegative(),
+})
+
+const scheduleAssignmentSchema = z.object({
+  element: z.object({
+    id: z.number().int().positive(),
+    name: z.string().min(1),
+    kind: z.string().min(1),
+    path: z.array(z.string().min(1)).min(1),
+  }),
+})
+
+export const scheduleDetailSchema = scheduleSummarySchema.extend({
+  days: z.array(
+    z.object({
+      date: isoDateSchema,
+      assignments: z.array(scheduleAssignmentSchema),
+    }),
+  ),
+})
+
+const schedulesResponseSchema = z.object({
+  schedules: z.array(scheduleSummarySchema),
+})
+
+const scheduleResponseSchema = z.object({
+  schedule: scheduleDetailSchema,
+})
+
+const errorResponseSchema = z.object({
+  error: z.string().min(1),
+})
+
+export type ScheduleSummary = z.infer<typeof scheduleSummarySchema>
+export type ScheduleDetail = z.infer<typeof scheduleDetailSchema>
+export type CreateScheduleInput = {
+  setId: number
+  elementKind: string
+  startDate: string
+  targetDate: string
+}
+
+const LIST_ERROR = "We couldn't load your schedules."
+const DETAIL_ERROR = "We couldn't load this schedule."
+const CREATE_ERROR = "We couldn't create this schedule."
+
+export const useSchedulesStore = defineStore('schedules', () => {
+  const schedules = ref<ScheduleSummary[]>([])
+  const listLoading = ref(false)
+  const listError = ref<string | null>(null)
+  const activeSchedule = ref<ScheduleDetail | null>(null)
+  const detailLoading = ref(false)
+  const detailError = ref<string | null>(null)
+  const detailNotFound = ref(false)
+  const creating = ref(false)
+  const createError = ref<string | null>(null)
+  let activeDetailRequestId = 0
+
+  async function fetchSchedules(): Promise<boolean> {
+    listLoading.value = true
+    listError.value = null
+
+    try {
+      const response = await fetch(`${API_BASE}/api/schedules`, {
+        method: 'GET',
+        credentials: 'include',
+        headers: {
+          Accept: 'application/json',
+        },
+      })
+
+      if (response.status !== 200) {
+        schedules.value = []
+        listError.value = LIST_ERROR
+
+        return false
+      }
+
+      const responseBody: unknown = await response.json()
+      schedules.value = schedulesResponseSchema.parse(responseBody).schedules
+
+      return true
+    } catch {
+      schedules.value = []
+      listError.value = LIST_ERROR
+
+      return false
+    } finally {
+      listLoading.value = false
+    }
+  }
+
+  async function fetchSchedule(scheduleId: number): Promise<boolean> {
+    const requestId = ++activeDetailRequestId
+    activeSchedule.value = null
+    detailLoading.value = true
+    detailError.value = null
+    detailNotFound.value = false
+
+    try {
+      const response = await fetch(`${API_BASE}/api/schedules/${scheduleId}`, {
+        method: 'GET',
+        credentials: 'include',
+        headers: {
+          Accept: 'application/json',
+        },
+      })
+
+      if (requestId !== activeDetailRequestId) {
+        return false
+      }
+
+      if (response.status === 404) {
+        detailNotFound.value = true
+
+        return false
+      }
+
+      if (response.status !== 200) {
+        detailError.value = DETAIL_ERROR
+
+        return false
+      }
+
+      const responseBody: unknown = await response.json()
+      if (requestId !== activeDetailRequestId) {
+        return false
+      }
+
+      const parsedSchedule = scheduleResponseSchema.parse(responseBody).schedule
+      if (parsedSchedule.id !== scheduleId) {
+        throw new Error('schedule response did not match requested schedule')
+      }
+      activeSchedule.value = parsedSchedule
+
+      return true
+    } catch {
+      if (requestId === activeDetailRequestId) {
+        activeSchedule.value = null
+        detailError.value = DETAIL_ERROR
+      }
+
+      return false
+    } finally {
+      if (requestId === activeDetailRequestId) {
+        detailLoading.value = false
+      }
+    }
+  }
+
+  async function createSchedule(input: CreateScheduleInput): Promise<ScheduleDetail | null> {
+    creating.value = true
+    createError.value = null
+
+    try {
+      const response = await fetch(`${API_BASE}/api/schedules`, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(input),
+      })
+      const responseBody: unknown = await response.json()
+
+      if (response.status !== 201) {
+        const parsedError = errorResponseSchema.safeParse(responseBody)
+        createError.value = parsedError.success ? parsedError.data.error : CREATE_ERROR
+
+        return null
+      }
+
+      const createdSchedule = scheduleResponseSchema.parse(responseBody).schedule
+      activeSchedule.value = createdSchedule
+      detailError.value = null
+      detailNotFound.value = false
+
+      return createdSchedule
+    } catch {
+      createError.value = CREATE_ERROR
+
+      return null
+    } finally {
+      creating.value = false
+    }
+  }
+
+  return {
+    schedules,
+    listLoading,
+    listError,
+    activeSchedule,
+    detailLoading,
+    detailError,
+    detailNotFound,
+    creating,
+    createError,
+    fetchSchedules,
+    fetchSchedule,
+    createSchedule,
+  }
+})
diff --git a/frontend/website/src/styles/main.css b/frontend/website/src/styles/main.css
index a121333..fa7661f 100644
--- a/frontend/website/src/styles/main.css
+++ b/frontend/website/src/styles/main.css
@@ -31,7 +31,8 @@ body {
 }
 
 button,
-input {
+input,
+select {
   font: inherit;
 }
 
diff --git a/frontend/website/src/views/CreateScheduleView.vue b/frontend/website/src/views/CreateScheduleView.vue
new file mode 100644
index 0000000..84cc585
--- /dev/null
+++ b/frontend/website/src/views/CreateScheduleView.vue
@@ -0,0 +1,405 @@
+<script setup lang="ts">
+import { storeToRefs } from 'pinia'
+import { computed, reactive, ref, watch } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import { z } from 'zod'
+
+import AuthenticatedHeader from '@/components/AuthenticatedHeader.vue'
+import { useSchedulesStore } from '@/stores/schedules'
+import { useSetLayoutStore, type SetElementNode } from '@/stores/setLayout'
+
+type ScheduleField = 'elementKind' | 'startDate' | 'targetDate'
+type ScheduleFieldErrors = Partial<Record<ScheduleField, string>>
+
+const route = useRoute()
+const router = useRouter()
+const setLayoutStore = useSetLayoutStore()
+const schedulesStore = useSchedulesStore()
+const { layout, loading, error, notFound } = storeToRefs(setLayoutStore)
+const { creating, createError } = storeToRefs(schedulesStore)
+const currentSetId = ref<number | null>(null)
+const form = reactive({
+  elementKind: '',
+  startDate: '',
+  targetDate: '',
+})
+const fieldErrors = ref<ScheduleFieldErrors>({})
+
+const levels = computed(() => {
+  const counts = new Map<string, number>()
+
+  function countNodes(nodes: SetElementNode[]): void {
+    for (const node of nodes) {
+      counts.set(node.kind, (counts.get(node.kind) ?? 0) + 1)
+      countNodes(node.children)
+    }
+  }
+
+  countNodes(layout.value?.elements ?? [])
+
+  return [...counts.entries()].map(([kind, count]) => ({
+    kind,
+    count,
+    label: humanizeKind(kind),
+  }))
+})
+
+const scheduleFormSchema = z
+  .object({
+    elementKind: z.string().min(1, 'Choose a level to schedule.'),
+    startDate: z.string().min(1, 'Choose a start date.'),
+    targetDate: z.string().min(1, 'Choose a target date.'),
+  })
+  .superRefine((value, context) => {
+    if (value.startDate !== '' && value.targetDate !== '' && value.targetDate < value.startDate) {
+      context.addIssue({
+        code: 'custom',
+        path: ['targetDate'],
+        message: 'Target date cannot be before the start date.',
+      })
+    }
+  })
+
+watch(
+  () => route.params.setId,
+  async (setIdParameter) => {
+    const rawSetId = Array.isArray(setIdParameter) ? setIdParameter[0] : setIdParameter
+    const setId = Number(rawSetId)
+    currentSetId.value = setId
+
+    if (layout.value?.set.id !== setId) {
+      await setLayoutStore.fetchSetLayout(setId)
+    }
+  },
+  { immediate: true },
+)
+
+async function submit(): Promise<void> {
+  fieldErrors.value = {}
+  const result = scheduleFormSchema.safeParse(form)
+  if (!result.success) {
+    const errors: ScheduleFieldErrors = {}
+    for (const issue of result.error.issues) {
+      const field = issue.path[0]
+      if (
+        (field === 'elementKind' || field === 'startDate' || field === 'targetDate') &&
+        errors[field] === undefined
+      ) {
+        errors[field] = issue.message
+      }
+    }
+    fieldErrors.value = errors
+
+    return
+  }
+
+  if (
+    currentSetId.value === null ||
+    !levels.value.some((level) => level.kind === result.data.elementKind)
+  ) {
+    fieldErrors.value = {
+      elementKind: 'Choose an available level to schedule.',
+    }
+
+    return
+  }
+
+  const schedule = await schedulesStore.createSchedule({
+    setId: currentSetId.value,
+    ...result.data,
+  })
+  if (schedule !== null) {
+    await router.push({
+      name: 'schedule-detail',
+      params: { scheduleId: schedule.id },
+    })
+  }
+}
+
+async function retry(): Promise<void> {
+  if (currentSetId.value !== null) {
+    await setLayoutStore.fetchSetLayout(currentSetId.value)
+  }
+}
+
+function humanizeKind(kind: string): string {
+  const words = kind.replaceAll(/[_-]+/g, ' ')
+
+  return words.charAt(0).toUpperCase() + words.slice(1)
+}
+</script>
+
+<template>
+  <main class="schedule-form-page">
+    <AuthenticatedHeader />
+
+    <section class="schedule-form-shell">
+      <RouterLink
+        class="back-link"
+        :to="{ name: 'set-layout', params: { setId: currentSetId ?? undefined } }"
+      >
+        <span aria-hidden="true">←</span>
+        Back to set
+      </RouterLink>
+
+      <p v-if="loading" class="page-state" role="status">Loading scheduling options...</p>
+
+      <div v-else-if="notFound" class="page-state page-state--error" role="alert">
+        <h1>Set not found</h1>
+        <p>The set you want to schedule is not available.</p>
+      </div>
+
+      <div v-else-if="error !== null" class="page-state page-state--error" role="alert">
+        <p>{{ error }}</p>
+        <button type="button" class="secondary-button" @click="retry">Try again</button>
+      </div>
+
+      <template v-else-if="layout !== null">
+        <header class="schedule-form__introduction">
+          <p class="eyebrow">Create schedule</p>
+          <h1>Schedule {{ layout.set.name }}</h1>
+          <p>Choose one level of the set and a date range. Every matching item will be included.</p>
+        </header>
+
+        <form class="schedule-form" novalidate @submit.prevent="submit">
+          <div class="form-field">
+            <label for="schedule-level">Level</label>
+            <select
+              id="schedule-level"
+              v-model="form.elementKind"
+              :aria-invalid="fieldErrors.elementKind !== undefined"
+              :aria-describedby="fieldErrors.elementKind ? 'schedule-level-error' : undefined"
+              :disabled="creating"
+            >
+              <option value="">Choose a level</option>
+              <option v-for="level in levels" :key="level.kind" :value="level.kind">
+                {{ level.label }} ({{ level.count }})
+              </option>
+            </select>
+            <p v-if="fieldErrors.elementKind" id="schedule-level-error" class="field-error">
+              {{ fieldErrors.elementKind }}
+            </p>
+          </div>
+
+          <div class="date-fields">
+            <div class="form-field">
+              <label for="schedule-start-date">Start date</label>
+              <input
+                id="schedule-start-date"
+                v-model="form.startDate"
+                type="date"
+                :aria-invalid="fieldErrors.startDate !== undefined"
+                :aria-describedby="fieldErrors.startDate ? 'schedule-start-date-error' : undefined"
+                :disabled="creating"
+              />
+              <p v-if="fieldErrors.startDate" id="schedule-start-date-error" class="field-error">
+                {{ fieldErrors.startDate }}
+              </p>
+            </div>
+
+            <div class="form-field">
+              <label for="schedule-target-date">Target date</label>
+              <input
+                id="schedule-target-date"
+                v-model="form.targetDate"
+                type="date"
+                :aria-invalid="fieldErrors.targetDate !== undefined"
+                :aria-describedby="
+                  fieldErrors.targetDate ? 'schedule-target-date-error' : undefined
+                "
+                :disabled="creating"
+              />
+              <p v-if="fieldErrors.targetDate" id="schedule-target-date-error" class="field-error">
+                {{ fieldErrors.targetDate }}
+              </p>
+            </div>
+          </div>
+
+          <p v-if="createError !== null" class="form-error" role="alert">{{ createError }}</p>
+
+          <button type="submit" class="primary-button" :disabled="creating">
+            {{ creating ? 'Creating schedule...' : 'Create schedule' }}
+          </button>
+        </form>
+      </template>
+    </section>
+  </main>
+</template>
+
+<style scoped>
+.schedule-form-page {
+  min-height: 100vh;
+  min-height: 100svh;
+  padding: 2rem clamp(1.5rem, 6vw, 5rem) 5rem;
+  color: #183029;
+  background: #f4f1e7;
+}
+
+.schedule-form-shell {
+  width: min(100%, 46rem);
+  margin: clamp(3.5rem, 8vh, 5.5rem) auto 0;
+}
+
+.back-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.45rem;
+  border-radius: 0.35rem;
+  color: #5e7067;
+  font-size: 0.84rem;
+  font-weight: 750;
+  text-decoration: none;
+}
+
+.back-link:focus-visible,
+.primary-button:focus-visible,
+.secondary-button:focus-visible,
+select:focus-visible,
+input:focus-visible {
+  outline: 3px solid rgb(86 127 112 / 34%);
+  outline-offset: 0.25rem;
+}
+
+.schedule-form__introduction {
+  margin-top: 2.75rem;
+}
+
+.eyebrow {
+  margin: 0 0 1rem;
+  color: #926044;
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+}
+
+h1 {
+  margin: 0;
+  font-family: Georgia, 'Times New Roman', serif;
+  font-size: clamp(2.75rem, 7vw, 4.8rem);
+  font-weight: 500;
+  line-height: 1;
+  letter-spacing: -0.05em;
+}
+
+.schedule-form__introduction > p:last-child {
+  max-width: 38rem;
+  margin: 1.4rem 0 0;
+  color: #68776f;
+  line-height: 1.7;
+}
+
+.schedule-form {
+  display: grid;
+  gap: 1.5rem;
+  margin-top: 2.75rem;
+  padding: clamp(1.3rem, 4vw, 2rem);
+  border: 1px solid rgb(24 48 41 / 12%);
+  border-radius: 1rem;
+  background: rgb(255 253 247 / 82%);
+  box-shadow: 0 1rem 2.5rem rgb(40 62 52 / 8%);
+}
+
+.form-field {
+  display: grid;
+  gap: 0.55rem;
+}
+
+.date-fields {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 1rem;
+}
+
+label {
+  font-size: 0.78rem;
+  font-weight: 800;
+}
+
+select,
+input {
+  width: 100%;
+  min-height: 3rem;
+  padding: 0.7rem 0.8rem;
+  border: 1px solid rgb(24 58 49 / 22%);
+  border-radius: 0.7rem;
+  color: #183029;
+  background: #fffdf7;
+}
+
+select[aria-invalid='true'],
+input[aria-invalid='true'] {
+  border-color: #a64b3c;
+}
+
+.field-error,
+.form-error {
+  margin: 0;
+  color: #934033;
+  font-size: 0.76rem;
+  line-height: 1.4;
+}
+
+.primary-button,
+.secondary-button {
+  min-height: 2.8rem;
+  padding: 0.7rem 1.1rem;
+  border-radius: 0.7rem;
+  font-weight: 750;
+  cursor: pointer;
+}
+
+.primary-button {
+  justify-self: start;
+  border: 0;
+  color: #fffdf7;
+  background: #183a31;
+}
+
+.primary-button:disabled {
+  cursor: wait;
+  opacity: 0.65;
+}
+
+.secondary-button {
+  border: 1px solid rgb(24 58 49 / 28%);
+  color: #183a31;
+  background: #fffdf7;
+}
+
+.page-state {
+  display: grid;
+  min-height: 10rem;
+  place-items: center;
+  margin-top: 2.75rem;
+  padding: 2rem;
+  border: 1px solid rgb(24 48 41 / 12%);
+  border-radius: 1rem;
+  color: #68776f;
+  background: rgb(255 253 247 / 72%);
+  text-align: center;
+}
+
+.page-state--error {
+  align-content: center;
+  gap: 1rem;
+}
+
+.page-state--error p {
+  margin: 0;
+}
+
+@media (max-width: 37.5rem) {
+  .schedule-form-page {
+    padding: 1.4rem 1.1rem 3rem;
+  }
+
+  .schedule-form-shell {
+    margin-top: 3rem;
+  }
+
+  .date-fields {
+    grid-template-columns: 1fr;
+  }
+}
+</style>
diff --git a/frontend/website/src/views/DashboardView.vue b/frontend/website/src/views/DashboardView.vue
index 9c77bf4..a2ccaf5 100644
--- a/frontend/website/src/views/DashboardView.vue
+++ b/frontend/website/src/views/DashboardView.vue
@@ -3,20 +3,89 @@ import { storeToRefs } from 'pinia'
 import { onMounted } from 'vue'
 
 import AuthenticatedHeader from '@/components/AuthenticatedHeader.vue'
+import { useSchedulesStore } from '@/stores/schedules'
 import { useSetsStore } from '@/stores/sets'
 
 const setsStore = useSetsStore()
+const schedulesStore = useSchedulesStore()
 const { sets, loading, error } = storeToRefs(setsStore)
+const { schedules, listLoading, listError } = storeToRefs(schedulesStore)
 
 onMounted(async () => {
-  await setsStore.fetchSets()
+  await Promise.all([setsStore.fetchSets(), schedulesStore.fetchSchedules()])
 })
+
+function humanizeKind(kind: string): string {
+  const words = kind.replaceAll(/[_-]+/g, ' ')
+
+  return words.charAt(0).toUpperCase() + words.slice(1)
+}
+
+function formatDate(value: string): string {
+  return new Intl.DateTimeFormat('en', {
+    dateStyle: 'medium',
+    timeZone: 'UTC',
+  }).format(new Date(`${value}T00:00:00Z`))
+}
 </script>
 
 <template>
   <main class="dashboard-page">
     <AuthenticatedHeader />
 
+    <section class="schedules-catalog" aria-labelledby="schedules-heading">
+      <div class="schedules-catalog__heading">
+        <div>
+          <p class="sets-catalog__eyebrow">Your plans</p>
+          <h2 id="schedules-heading">Your schedules</h2>
+        </div>
+        <p>Return to a plan and see what is assigned for each day.</p>
+      </div>
+
+      <p v-if="listLoading" class="catalog-state catalog-state--compact" role="status">
+        Loading schedules...
+      </p>
+
+      <div
+        v-else-if="listError !== null"
+        class="catalog-state catalog-state--compact catalog-state--error"
+        role="alert"
+      >
+        <p>{{ listError }}</p>
+        <button type="button" class="retry-button" @click="schedulesStore.fetchSchedules">
+          Try again
+        </button>
+      </div>
+
+      <p
+        v-else-if="schedules.length === 0"
+        class="catalog-state catalog-state--compact"
+        role="status"
+      >
+        You have not created a schedule yet.
+      </p>
+
+      <ul v-else class="schedule-grid" aria-label="Your schedules">
+        <li v-for="schedule in schedules" :key="schedule.id">
+          <RouterLink
+            class="schedule-card-link"
+            :to="{ name: 'schedule-detail', params: { scheduleId: schedule.id } }"
+          >
+            <article class="schedule-card">
+              <div class="schedule-card__heading">
+                <p>{{ humanizeKind(schedule.elementKind) }}</p>
+                <span>{{ schedule.assignmentCount }} assignments</span>
+              </div>
+              <h3>{{ schedule.set.name }}</h3>
+              <span class="schedule-card__dates">
+                {{ formatDate(schedule.startDate) }} to {{ formatDate(schedule.targetDate) }}
+              </span>
+            </article>
+          </RouterLink>
+        </li>
+      </ul>
+    </section>
+
     <section class="sets-catalog" aria-labelledby="sets-heading">
       <div class="sets-catalog__introduction">
         <p class="sets-catalog__eyebrow">Your library</p>
@@ -72,6 +141,34 @@ onMounted(async () => {
   margin: clamp(4.5rem, 10vh, 7rem) auto 0;
 }
 
+.schedules-catalog {
+  width: min(100%, 72rem);
+  margin: clamp(4.5rem, 10vh, 7rem) auto 0;
+}
+
+.schedules-catalog__heading {
+  display: flex;
+  align-items: end;
+  justify-content: space-between;
+  gap: 2rem;
+}
+
+.schedules-catalog__heading h2 {
+  margin: 0;
+  font-family: Georgia, 'Times New Roman', serif;
+  font-size: clamp(2.25rem, 5vw, 3.5rem);
+  font-weight: 500;
+  line-height: 1;
+  letter-spacing: -0.045em;
+}
+
+.schedules-catalog__heading > p {
+  max-width: 24rem;
+  margin: 0;
+  color: #68776f;
+  line-height: 1.6;
+}
+
 .sets-catalog__introduction {
   max-width: 44rem;
 }
@@ -120,6 +217,11 @@ h1 {
   gap: 1rem;
 }
 
+.catalog-state--compact {
+  min-height: 7rem;
+  margin-top: 2rem;
+}
+
 .catalog-state--error p {
   margin: 0;
 }
@@ -155,6 +257,74 @@ h1 {
   list-style: none;
 }
 
+.schedule-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 18rem), 1fr));
+  gap: 1rem;
+  margin: 2rem 0 0;
+  padding: 0;
+  list-style: none;
+}
+
+.schedule-card-link {
+  display: block;
+  height: 100%;
+  border-radius: 1rem;
+  text-decoration: none;
+}
+
+.schedule-card {
+  height: 100%;
+  padding: 1.4rem;
+  border: 1px solid rgb(24 48 41 / 12%);
+  border-radius: 1rem;
+  background: rgb(255 253 247 / 88%);
+  box-shadow: 0 0.75rem 2rem rgb(40 62 52 / 7%);
+  transition:
+    border-color 160ms ease,
+    transform 160ms ease;
+}
+
+.schedule-card-link:hover .schedule-card {
+  border-color: rgb(40 92 78 / 35%);
+  transform: translateY(-2px);
+}
+
+.schedule-card-link:focus-visible {
+  outline: 3px solid rgb(86 127 112 / 38%);
+  outline-offset: 0.25rem;
+}
+
+.schedule-card__heading {
+  display: flex;
+  justify-content: space-between;
+  gap: 1rem;
+  color: #926044;
+  font-size: 0.68rem;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.schedule-card__heading p {
+  margin: 0;
+}
+
+.schedule-card h3 {
+  margin: 2rem 0 0;
+  font-family: Georgia, 'Times New Roman', serif;
+  font-size: 1.8rem;
+  font-weight: 500;
+  line-height: 1.1;
+}
+
+.schedule-card__dates {
+  display: block;
+  margin-top: 1rem;
+  color: #68776f;
+  font-size: 0.78rem;
+}
+
 .set-card {
   height: 100%;
   min-height: 11rem;
@@ -225,6 +395,15 @@ h1 {
     margin-top: 3.75rem;
   }
 
+  .schedules-catalog {
+    margin-top: 3.75rem;
+  }
+
+  .schedules-catalog__heading {
+    display: grid;
+    gap: 1rem;
+  }
+
   .set-grid {
     margin-top: 2.25rem;
   }
diff --git a/frontend/website/src/views/ScheduleDetailView.vue b/frontend/website/src/views/ScheduleDetailView.vue
new file mode 100644
index 0000000..0471be6
--- /dev/null
+++ b/frontend/website/src/views/ScheduleDetailView.vue
@@ -0,0 +1,323 @@
+<script setup lang="ts">
+import { storeToRefs } from 'pinia'
+import { ref, watch } from 'vue'
+import { useRoute } from 'vue-router'
+
+import AuthenticatedHeader from '@/components/AuthenticatedHeader.vue'
+import { useSchedulesStore } from '@/stores/schedules'
+
+const route = useRoute()
+const schedulesStore = useSchedulesStore()
+const { activeSchedule, detailLoading, detailError, detailNotFound } = storeToRefs(schedulesStore)
+const currentScheduleId = ref<number | null>(null)
+
+watch(
+  () => route.params.scheduleId,
+  async (scheduleIdParameter) => {
+    const rawScheduleId = Array.isArray(scheduleIdParameter)
+      ? scheduleIdParameter[0]
+      : scheduleIdParameter
+    const scheduleId = Number(rawScheduleId)
+    currentScheduleId.value = scheduleId
+
+    if (activeSchedule.value?.id !== scheduleId) {
+      await schedulesStore.fetchSchedule(scheduleId)
+    }
+  },
+  { immediate: true },
+)
+
+async function retry(): Promise<void> {
+  if (currentScheduleId.value !== null) {
+    await schedulesStore.fetchSchedule(currentScheduleId.value)
+  }
+}
+
+function formatDate(value: string): string {
+  return new Intl.DateTimeFormat('en', {
+    dateStyle: 'medium',
+    timeZone: 'UTC',
+  }).format(new Date(`${value}T00:00:00Z`))
+}
+
+function humanizeKind(kind: string): string {
+  const words = kind.replaceAll(/[_-]+/g, ' ')
+
+  return words.charAt(0).toUpperCase() + words.slice(1)
+}
+
+function pluralKind(kind: string, count: number): string {
+  if (count === 1) {
+    return kind
+  }
+
+  if (kind.endsWith('y')) {
+    return `${kind.slice(0, -1)}ies`
+  }
+
+  if (kind.endsWith('s')) {
+    return kind
+  }
+
+  return `${kind}s`
+}
+</script>
+
+<template>
+  <main class="schedule-page">
+    <AuthenticatedHeader />
+
+    <section class="schedule-shell">
+      <RouterLink class="back-link" :to="{ name: 'dashboard' }">
+        <span aria-hidden="true">←</span>
+        Back to dashboard
+      </RouterLink>
+
+      <p v-if="detailLoading" class="page-state" role="status">Loading schedule...</p>
+
+      <div v-else-if="detailNotFound" class="page-state page-state--error" role="alert">
+        <h1>Schedule not found</h1>
+        <p>This schedule is not available.</p>
+      </div>
+
+      <div v-else-if="detailError !== null" class="page-state page-state--error" role="alert">
+        <p>{{ detailError }}</p>
+        <button type="button" class="retry-button" @click="retry">Try again</button>
+      </div>
+
+      <template v-else-if="activeSchedule !== null">
+        <header class="schedule-introduction">
+          <p class="eyebrow">{{ humanizeKind(activeSchedule.elementKind) }} plan</p>
+          <h1>{{ activeSchedule.set.name }} schedule</h1>
+          <p class="schedule-summary">
+            {{ activeSchedule.assignmentCount }}
+            {{ pluralKind(activeSchedule.elementKind, activeSchedule.assignmentCount) }} across
+            {{ activeSchedule.days.length }}
+            {{ activeSchedule.days.length === 1 ? 'day' : 'days' }}
+          </p>
+          <p class="schedule-range">
+            {{ formatDate(activeSchedule.startDate) }} to
+            {{ formatDate(activeSchedule.targetDate) }}
+          </p>
+        </header>
+
+        <ol class="schedule-days" aria-label="Scheduled days">
+          <li
+            v-for="day in activeSchedule.days"
+            :key="day.date"
+            class="schedule-day"
+            data-schedule-day
+            :data-schedule-date="day.date"
+          >
+            <header class="schedule-day__header">
+              <time :datetime="day.date">{{ formatDate(day.date) }}</time>
+              <span>{{ day.assignments.length }} assigned</span>
+            </header>
+
+            <p v-if="day.assignments.length === 0" class="rest-day">Rest day</p>
+
+            <ul v-else class="assignment-list">
+              <li v-for="assignment in day.assignments" :key="assignment.element.id">
+                <span class="assignment-path">{{ assignment.element.path.join(' / ') }}</span>
+                <span class="assignment-kind">{{ humanizeKind(assignment.element.kind) }}</span>
+              </li>
+            </ul>
+          </li>
+        </ol>
+      </template>
+    </section>
+  </main>
+</template>
+
+<style scoped>
+.schedule-page {
+  min-height: 100vh;
+  min-height: 100svh;
+  padding: 2rem clamp(1.5rem, 6vw, 5rem) 5rem;
+  color: #183029;
+  background: #f4f1e7;
+}
+
+.schedule-shell {
+  width: min(100%, 56rem);
+  margin: clamp(3.5rem, 8vh, 5.5rem) auto 0;
+}
+
+.back-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.45rem;
+  border-radius: 0.35rem;
+  color: #5e7067;
+  font-size: 0.84rem;
+  font-weight: 750;
+  text-decoration: none;
+}
+
+.back-link:focus-visible,
+.retry-button:focus-visible {
+  outline: 3px solid rgb(86 127 112 / 34%);
+  outline-offset: 0.25rem;
+}
+
+.schedule-introduction {
+  margin-top: 2.75rem;
+}
+
+.eyebrow {
+  margin: 0 0 1rem;
+  color: #926044;
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+}
+
+h1 {
+  margin: 0;
+  font-family: Georgia, 'Times New Roman', serif;
+  font-size: clamp(3rem, 7vw, 5.25rem);
+  font-weight: 500;
+  line-height: 1;
+  letter-spacing: -0.055em;
+}
+
+.schedule-summary {
+  margin: 1.35rem 0 0;
+  color: #344e45;
+  font-weight: 750;
+}
+
+.schedule-range {
+  margin: 0.5rem 0 0;
+  color: #68776f;
+}
+
+.schedule-days {
+  display: grid;
+  gap: 1rem;
+  margin: 3rem 0 0;
+  padding: 0;
+  list-style: none;
+}
+
+.schedule-day {
+  overflow: hidden;
+  border: 1px solid rgb(24 48 41 / 12%);
+  border-radius: 1rem;
+  background: rgb(255 253 247 / 82%);
+  box-shadow: 0 0.75rem 2rem rgb(40 62 52 / 6%);
+}
+
+.schedule-day__header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  padding: 0.85rem 1rem;
+  border-bottom: 1px solid rgb(24 48 41 / 10%);
+  color: #5e7067;
+  background: rgb(239 228 212 / 42%);
+  font-size: 0.75rem;
+  font-weight: 800;
+}
+
+.rest-day {
+  margin: 0;
+  padding: 1.2rem 1rem;
+  color: #79877f;
+  font-style: italic;
+}
+
+.assignment-list {
+  display: grid;
+  gap: 0;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.assignment-list li {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  padding: 1rem;
+}
+
+.assignment-list li + li {
+  border-top: 1px solid rgb(24 48 41 / 10%);
+}
+
+.assignment-path {
+  min-width: 0;
+  font-family: Georgia, 'Times New Roman', serif;
+  font-size: 1.05rem;
+  overflow-wrap: anywhere;
+}
+
+.assignment-kind {
+  flex: 0 0 auto;
+  padding: 0.35rem 0.55rem;
+  border-radius: 999px;
+  color: #81533a;
+  background: #efe4d4;
+  font-size: 0.62rem;
+  font-weight: 800;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+}
+
+.page-state {
+  display: grid;
+  min-height: 10rem;
+  place-items: center;
+  margin-top: 2.75rem;
+  padding: 2rem;
+  border: 1px solid rgb(24 48 41 / 12%);
+  border-radius: 1rem;
+  color: #68776f;
+  background: rgb(255 253 247 / 72%);
+  text-align: center;
+}
+
+.page-state--error {
+  align-content: center;
+  gap: 1rem;
+}
+
+.page-state--error h1,
+.page-state--error p {
+  margin: 0;
+}
+
+.page-state--error h1 {
+  font-size: clamp(2.25rem, 5vw, 3.6rem);
+}
+
+.retry-button {
+  min-height: 2.65rem;
+  padding: 0.65rem 1rem;
+  border: 1px solid rgb(24 58 49 / 28%);
+  border-radius: 0.7rem;
+  color: #183a31;
+  background: #fffdf7;
+  font-size: 0.82rem;
+  font-weight: 750;
+  cursor: pointer;
+}
+
+@media (max-width: 37.5rem) {
+  .schedule-page {
+    padding: 1.4rem 1.1rem 3rem;
+  }
+
+  .schedule-shell {
+    margin-top: 3rem;
+  }
+
+  .assignment-list li {
+    align-items: flex-start;
+  }
+}
+</style>
diff --git a/frontend/website/src/views/SetLayoutView.vue b/frontend/website/src/views/SetLayoutView.vue
index 582f6b5..6edf2b9 100644
--- a/frontend/website/src/views/SetLayoutView.vue
+++ b/frontend/website/src/views/SetLayoutView.vue
@@ -63,6 +63,14 @@ async function retry(): Promise<void> {
           <p class="set-layout__description">
             Explore every element in this set and see how each level fits into the whole.
           </p>
+          <RouterLink
+            v-if="layout.elements.length > 0"
+            class="schedule-link"
+            :to="{ name: 'schedule-create', params: { setId: layout.set.id } }"
+          >
+            Schedule this set
+            <span aria-hidden="true">→</span>
+          </RouterLink>
         </header>
 
         <p
@@ -145,6 +153,31 @@ h1 {
   line-height: 1.7;
 }
 
+.schedule-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+  min-height: 2.8rem;
+  margin-top: 1.5rem;
+  padding: 0.7rem 1rem;
+  border-radius: 0.7rem;
+  color: #fffdf7;
+  background: #183a31;
+  box-shadow: 0 0.55rem 1.2rem rgb(24 58 49 / 14%);
+  font-size: 0.82rem;
+  font-weight: 750;
+  text-decoration: none;
+}
+
+.schedule-link:hover {
+  background: #285c4e;
+}
+
+.schedule-link:focus-visible {
+  outline: 3px solid rgb(86 127 112 / 34%);
+  outline-offset: 0.25rem;
+}
+
 .layout-outline {
   margin-top: 3rem;
 }

From 92905c981ba2d83046aa138ca0e70e41cf5b3f42 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 20:19:00 +0300
Subject: [PATCH 06/25] scope dashboard status checks

---
 frontend/website/cypress/e2e/sets-dashboard.cy.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/frontend/website/cypress/e2e/sets-dashboard.cy.ts b/frontend/website/cypress/e2e/sets-dashboard.cy.ts
index 6cff9ed..2557ded 100644
--- a/frontend/website/cypress/e2e/sets-dashboard.cy.ts
+++ b/frontend/website/cypress/e2e/sets-dashboard.cy.ts
@@ -68,10 +68,10 @@ describe('sets dashboard', () => {
 
     cy.visit('/dashboard')
     cy.wait('@me')
-    cy.get('[role="status"]').should('have.text', 'Loading sets...')
+    cy.get('.sets-catalog [role="status"]').should('have.text', 'Loading sets...')
     cy.wait('@sets')
 
-    cy.get('[role="status"]').should(
+    cy.get('.sets-catalog [role="status"]').should(
       'contain.text',
       'No sets are available yet.',
     )

From 14fe2fcb46135cbbf39ef6c12da0f1a39fd551c5 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 22:33:44 +0300
Subject: [PATCH 07/25] test stable schedule snapshots

---
 .../tests/Fakes/FakeScheduleRepository.php    | 12 ++-
 .../Feature/Schedule/ScheduleEndpointTest.php | 78 +++++++++++++++++--
 .../Schedule/UseCases/CreateScheduleTest.php  | 18 +++--
 3 files changed, 91 insertions(+), 17 deletions(-)

diff --git a/backend/tests/Fakes/FakeScheduleRepository.php b/backend/tests/Fakes/FakeScheduleRepository.php
index 06e281e..de1ae76 100644
--- a/backend/tests/Fakes/FakeScheduleRepository.php
+++ b/backend/tests/Fakes/FakeScheduleRepository.php
@@ -23,7 +23,9 @@ class FakeScheduleRepository implements ScheduleRepository
         foreach ($dto->assignments as $assignmentDto) {
             $assignments[] = new ScheduleAssignment(
                 id: count($assignments) + 1,
-                element: $assignmentDto->element,
+                name: $assignmentDto->name,
+                kind: $assignmentDto->kind,
+                path: $assignmentDto->path,
                 scheduledDate: $assignmentDto->scheduledDate,
                 position: $assignmentDto->position,
             );
@@ -32,7 +34,7 @@ class FakeScheduleRepository implements ScheduleRepository
         $schedule = new Schedule(
             id: $id,
             user: $dto->user,
-            set: $dto->set,
+            setName: $dto->setName,
             elementKind: $dto->elementKind,
             startDate: $dto->startDate,
             targetDate: $dto->targetDate,
@@ -76,7 +78,9 @@ class FakeScheduleRepository implements ScheduleRepository
             function (ScheduleAssignment $assignment): ScheduleAssignment {
                 return new ScheduleAssignment(
                     id: $assignment->getId(),
-                    element: $assignment->getElement(),
+                    name: $assignment->getName(),
+                    kind: $assignment->getKind(),
+                    path: $assignment->getPath(),
                     scheduledDate: $assignment->getScheduledDate(),
                     position: $assignment->getPosition(),
                 );
@@ -87,7 +91,7 @@ class FakeScheduleRepository implements ScheduleRepository
         return new Schedule(
             id: $schedule->getId(),
             user: $schedule->getUser(),
-            set: $schedule->getSet(),
+            setName: $schedule->getSetName(),
             elementKind: $schedule->getElementKind(),
             startDate: $schedule->getStartDate(),
             targetDate: $schedule->getTargetDate(),
diff --git a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
index 6b9a679..1093de8 100644
--- a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
+++ b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
@@ -5,10 +5,12 @@ namespace Tests\Feature\Schedule;
 use App\Auth\CreateSessionDto;
 use App\Auth\SessionRepository;
 use App\Element\CreateElementDto;
+use App\Element\ElementModel;
 use App\Element\ElementRepository;
 use App\Http\Middleware\AuthMiddleware;
 use App\Set\CreateSetDto;
 use App\Set\Set;
+use App\Set\SetModel;
 use App\Set\SetRepository;
 use App\Shared\ValueObject\EmailAddress;
 use App\User\CreateUserDto;
@@ -17,6 +19,7 @@ use App\User\UserRepository;
 use DateTimeImmutable;
 use DateTimeZone;
 use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Schema;
 use Illuminate\Testing\TestResponse;
 use Tests\TestCase;
 
@@ -73,7 +76,6 @@ class ScheduleEndpointTest extends TestCase
             'schedule' => [
                 'id' => 1,
                 'set' => [
-                    'id' => $set->getId(),
                     'name' => 'Bible',
                 ],
                 'elementKind' => 'chapter',
@@ -85,8 +87,8 @@ class ScheduleEndpointTest extends TestCase
                         'date' => '2026-08-10',
                         'assignments' => [
                             [
+                                'id' => 1,
                                 'element' => [
-                                    'id' => $chapterOne->getId(),
                                     'name' => 'Chapter 1',
                                     'kind' => 'chapter',
                                     'path' => [
@@ -106,8 +108,8 @@ class ScheduleEndpointTest extends TestCase
                         'date' => '2026-08-12',
                         'assignments' => [
                             [
+                                'id' => 2,
                                 'element' => [
-                                    'id' => $chapterTwo->getId(),
                                     'name' => 'Chapter 1',
                                     'kind' => 'chapter',
                                     'path' => [
@@ -123,12 +125,29 @@ class ScheduleEndpointTest extends TestCase
         ]);
         $this->assertDatabaseHas('schedules', [
             'user_id' => $user->getId(),
-            'set_id' => $set->getId(),
+            'set_name' => 'Bible',
             'element_kind' => 'chapter',
             'start_date' => '2026-08-10',
             'target_date' => '2026-08-12',
         ]);
+        $this->assertDatabaseHas('schedule_assignments', [
+            'schedule_id' => 1,
+            'element_name' => 'Chapter 1',
+            'element_kind' => 'chapter',
+            'element_path' => json_encode([
+                'Genesis',
+                'Creation',
+                'Chapter 1',
+            ]),
+            'scheduled_date' => '2026-08-10',
+            'position' => 1,
+        ]);
         $this->assertDatabaseCount('schedule_assignments', 2);
+        $this->assertFalse(Schema::hasColumn('schedules', 'set_id'));
+        $this->assertFalse(Schema::hasColumn(
+            'schedule_assignments',
+            'element_id',
+        ));
 
         $this->credentialedGet('/api/schedules/1')
             ->assertOk()
@@ -179,7 +198,6 @@ class ScheduleEndpointTest extends TestCase
                     [
                         'id' => 2,
                         'set' => [
-                            'id' => $set->getId(),
                             'name' => 'Course',
                         ],
                         'elementKind' => 'lesson',
@@ -190,7 +208,6 @@ class ScheduleEndpointTest extends TestCase
                     [
                         'id' => 1,
                         'set' => [
-                            'id' => $set->getId(),
                             'name' => 'Course',
                         ],
                         'elementKind' => 'lesson',
@@ -202,6 +219,55 @@ class ScheduleEndpointTest extends TestCase
             ]);
     }
 
+    public function test_it_is_stable_after_sources_change_or_are_deleted(): void
+    {
+        $user = $this->createUser('reader@example.com');
+        $set = $this->createSet($user, 'Original set');
+        $repository = app(ElementRepository::class);
+        $parent = $repository->create(new CreateElementDto(
+            set: $set,
+            name: 'Original parent',
+            kind: 'group',
+            parentElement: null,
+        ));
+        $element = $repository->create(new CreateElementDto(
+            set: $set,
+            name: 'Original item',
+            kind: 'task',
+            parentElement: $parent,
+        ));
+        $this->createSession($user, 'valid-token');
+        $createdResponse = $this->credentialedPost('/api/schedules', [
+            'setId' => $set->getId(),
+            'elementKind' => 'task',
+            'startDate' => '2026-08-10',
+            'targetDate' => '2026-08-10',
+        ])->assertCreated();
+
+        SetModel::query()->whereKey($set->getId())->update([
+            'name' => 'Changed set',
+        ]);
+        ElementModel::query()->whereKey($parent->getId())->update([
+            'name' => 'Changed parent',
+        ]);
+        ElementModel::query()->whereKey($element->getId())->update([
+            'name' => 'Changed item',
+            'kind' => 'changed-kind',
+        ]);
+
+        $this->credentialedGet('/api/schedules/1')
+            ->assertOk()
+            ->assertExactJson($createdResponse->json());
+
+        ElementModel::query()->whereKey($element->getId())->delete();
+        ElementModel::query()->whereKey($parent->getId())->delete();
+        SetModel::query()->whereKey($set->getId())->delete();
+
+        $this->credentialedGet('/api/schedules/1')
+            ->assertOk()
+            ->assertExactJson($createdResponse->json());
+    }
+
     public function test_it_hides_another_users_schedule(): void
     {
         $owner = $this->createUser('owner@example.com');
diff --git a/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php b/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
index 3814a56..3a4e715 100644
--- a/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
+++ b/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
@@ -107,16 +107,20 @@ class CreateScheduleTest extends TestCase
         ));
         $this->assertSame(
             [
-                $genesisChapterOne->getId(),
-                $genesisChapterTwo->getId(),
-                $genesisChapterThree->getId(),
-                $exodusChapterOne->getId(),
-                $exodusChapterTwo->getId(),
+                $genesisChapterOne->getName(),
+                $genesisChapterTwo->getName(),
+                $genesisChapterThree->getName(),
+                $exodusChapterOne->getName(),
+                $exodusChapterTwo->getName(),
             ],
-            array_map(function ($assignment): int {
-                return $assignment->getElement()->getId();
+            array_map(function ($assignment): string {
+                return $assignment->getName();
             }, $schedule->getAssignments()),
         );
+        $this->assertSame(
+            ['Genesis', 'Creation', 'Genesis 1'],
+            $schedule->getAssignments()[0]->getPath(),
+        );
         $this->assertSame(
             [
                 '2026-08-10',

From f500bd60958f1ba9ec15d5874caba79ceabed1df Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 22:36:14 +0300
Subject: [PATCH 08/25] snapshot schedule source data

---
 .../Http/Controllers/ScheduleController.php   | 35 ++++---------------
 .../Schedule/CreateScheduleAssignmentDto.php  |  8 +++--
 backend/app/Schedule/CreateScheduleDto.php    |  3 +-
 .../Schedule/EloquentScheduleRepository.php   | 32 +++++------------
 backend/app/Schedule/Schedule.php             |  7 ++--
 backend/app/Schedule/ScheduleAssignment.php   | 25 ++++++++++---
 .../app/Schedule/ScheduleAssignmentModel.php  | 10 ++++--
 backend/app/Schedule/ScheduleModel.php        |  5 ++-
 .../CreateSchedule/CreateSchedule.php         | 22 ++++++++++--
 ...26_08_10_000000_create_schedules_table.php |  4 +--
 ...0001_create_schedule_assignments_table.php |  7 ++--
 .../website/cypress/e2e/set-scheduling.cy.ts  |  8 ++---
 frontend/website/src/stores/schedules.ts      |  3 +-
 .../website/src/views/ScheduleDetailView.vue  |  2 +-
 14 files changed, 84 insertions(+), 87 deletions(-)

diff --git a/backend/app/Http/Controllers/ScheduleController.php b/backend/app/Http/Controllers/ScheduleController.php
index 3ff4a39..fb0bb40 100644
--- a/backend/app/Http/Controllers/ScheduleController.php
+++ b/backend/app/Http/Controllers/ScheduleController.php
@@ -2,7 +2,6 @@
 
 namespace App\Http\Controllers;
 
-use App\Element\Element;
 use App\Exceptions\BadRequestException;
 use App\Exceptions\NotFoundException;
 use App\Schedule\Schedule;
@@ -96,13 +95,10 @@ class ScheduleController extends Controller
      */
     private function summaryPayload(Schedule $schedule): array
     {
-        $set = $schedule->getSet();
-
         return [
             'id' => $schedule->getId(),
             'set' => [
-                'id' => $set->getId(),
-                'name' => $set->getName(),
+                'name' => $schedule->getSetName(),
             ],
             'elementKind' => $schedule->getElementKind(),
             'startDate' => $schedule->getStartDate()->format('Y-m-d'),
@@ -150,8 +146,7 @@ class ScheduleController extends Controller
     }
 
     /**
-     * @return array{element: array{
-     *     id: int,
+     * @return array{id: int, element: array{
      *     name: string,
      *     kind: string,
      *     path: list<string>
@@ -160,34 +155,16 @@ class ScheduleController extends Controller
     private function assignmentPayload(
         ScheduleAssignment $assignment,
     ): array {
-        $element = $assignment->getElement();
-
         return [
+            'id' => $assignment->getId(),
             'element' => [
-                'id' => $element->getId(),
-                'name' => $element->getName(),
-                'kind' => $element->getKind(),
-                'path' => $this->elementPath($element),
+                'name' => $assignment->getName(),
+                'kind' => $assignment->getKind(),
+                'path' => $assignment->getPath(),
             ],
         ];
     }
 
-    /**
-     * @return list<string>
-     */
-    private function elementPath(Element $element): array
-    {
-        $path = [];
-        $currentElement = $element;
-
-        while ($currentElement !== null) {
-            array_unshift($path, $currentElement->getName());
-            $currentElement = $currentElement->getParentElement();
-        }
-
-        return $path;
-    }
-
     private function user(Request $request): User
     {
         /** @var User $user */
diff --git a/backend/app/Schedule/CreateScheduleAssignmentDto.php b/backend/app/Schedule/CreateScheduleAssignmentDto.php
index 682438c..6acf329 100644
--- a/backend/app/Schedule/CreateScheduleAssignmentDto.php
+++ b/backend/app/Schedule/CreateScheduleAssignmentDto.php
@@ -2,13 +2,17 @@
 
 namespace App\Schedule;
 
-use App\Element\Element;
 use DateTimeImmutable;
 
 final readonly class CreateScheduleAssignmentDto
 {
+    /**
+     * @param list<string> $path
+     */
     public function __construct(
-        public Element $element,
+        public string $name,
+        public string $kind,
+        public array $path,
         public DateTimeImmutable $scheduledDate,
         public int $position,
     ) {}
diff --git a/backend/app/Schedule/CreateScheduleDto.php b/backend/app/Schedule/CreateScheduleDto.php
index 4683bc6..5c5ffdc 100644
--- a/backend/app/Schedule/CreateScheduleDto.php
+++ b/backend/app/Schedule/CreateScheduleDto.php
@@ -2,7 +2,6 @@
 
 namespace App\Schedule;
 
-use App\Set\Set;
 use App\User\User;
 use DateTimeImmutable;
 
@@ -13,7 +12,7 @@ final readonly class CreateScheduleDto
      */
     public function __construct(
         public User $user,
-        public Set $set,
+        public string $setName,
         public string $elementKind,
         public DateTimeImmutable $startDate,
         public DateTimeImmutable $targetDate,
diff --git a/backend/app/Schedule/EloquentScheduleRepository.php b/backend/app/Schedule/EloquentScheduleRepository.php
index f23cb30..31bb859 100644
--- a/backend/app/Schedule/EloquentScheduleRepository.php
+++ b/backend/app/Schedule/EloquentScheduleRepository.php
@@ -2,27 +2,19 @@
 
 namespace App\Schedule;
 
-use App\Element\ElementRepository;
-use App\Set\SetRepository;
 use App\User\User;
 use DateTimeImmutable;
 use DateTimeZone;
 use Illuminate\Support\Facades\DB;
-use RuntimeException;
 
 class EloquentScheduleRepository implements ScheduleRepository
 {
-    public function __construct(
-        private SetRepository $setRepository,
-        private ElementRepository $elementRepository,
-    ) {}
-
     public function create(CreateScheduleDto $dto): Schedule
     {
         return DB::transaction(function () use ($dto): Schedule {
             $model = ScheduleModel::create([
                 'user_id' => $dto->user->getId(),
-                'set_id' => $dto->set->getId(),
+                'set_name' => $dto->setName,
                 'element_kind' => $dto->elementKind,
                 'start_date' => $dto->startDate->format('Y-m-d'),
                 'target_date' => $dto->targetDate->format('Y-m-d'),
@@ -31,7 +23,9 @@ class EloquentScheduleRepository implements ScheduleRepository
             foreach ($dto->assignments as $assignmentDto) {
                 ScheduleAssignmentModel::create([
                     'schedule_id' => $model->id,
-                    'element_id' => $assignmentDto->element->getId(),
+                    'element_name' => $assignmentDto->name,
+                    'element_kind' => $assignmentDto->kind,
+                    'element_path' => $assignmentDto->path,
                     'scheduled_date' => $assignmentDto->scheduledDate
                         ->format('Y-m-d'),
                     'position' => $assignmentDto->position,
@@ -69,11 +63,6 @@ class EloquentScheduleRepository implements ScheduleRepository
 
     private function toDomain(ScheduleModel $model, User $user): Schedule
     {
-        $set = $this->setRepository->find($model->set_id);
-        if ($set === null) {
-            throw new RuntimeException('schedule set not found');
-        }
-
         $assignmentModels = ScheduleAssignmentModel::query()
             ->where('schedule_id', $model->id)
             ->orderBy('position')
@@ -82,16 +71,11 @@ class EloquentScheduleRepository implements ScheduleRepository
         $assignments = [];
 
         foreach ($assignmentModels as $assignmentModel) {
-            $element = $this->elementRepository->find(
-                $assignmentModel->element_id,
-            );
-            if ($element === null) {
-                throw new RuntimeException('schedule element not found');
-            }
-
             $assignments[] = new ScheduleAssignment(
                 id: $assignmentModel->id,
-                element: $element,
+                name: $assignmentModel->element_name,
+                kind: $assignmentModel->element_kind,
+                path: $assignmentModel->element_path,
                 scheduledDate: $this->date($assignmentModel->scheduled_date),
                 position: $assignmentModel->position,
             );
@@ -100,7 +84,7 @@ class EloquentScheduleRepository implements ScheduleRepository
         return new Schedule(
             id: $model->id,
             user: $user,
-            set: $set,
+            setName: $model->set_name,
             elementKind: $model->element_kind,
             startDate: $this->date($model->start_date),
             targetDate: $this->date($model->target_date),
diff --git a/backend/app/Schedule/Schedule.php b/backend/app/Schedule/Schedule.php
index ecb3cfa..0a14ce8 100644
--- a/backend/app/Schedule/Schedule.php
+++ b/backend/app/Schedule/Schedule.php
@@ -2,7 +2,6 @@
 
 namespace App\Schedule;
 
-use App\Set\Set;
 use App\User\User;
 use DateTimeImmutable;
 
@@ -14,7 +13,7 @@ final readonly class Schedule
     public function __construct(
         private int $id,
         private User $user,
-        private Set $set,
+        private string $setName,
         private string $elementKind,
         private DateTimeImmutable $startDate,
         private DateTimeImmutable $targetDate,
@@ -31,9 +30,9 @@ final readonly class Schedule
         return $this->user;
     }
 
-    public function getSet(): Set
+    public function getSetName(): string
     {
-        return $this->set;
+        return $this->setName;
     }
 
     public function getElementKind(): string
diff --git a/backend/app/Schedule/ScheduleAssignment.php b/backend/app/Schedule/ScheduleAssignment.php
index 97c67a3..482b45d 100644
--- a/backend/app/Schedule/ScheduleAssignment.php
+++ b/backend/app/Schedule/ScheduleAssignment.php
@@ -2,14 +2,18 @@
 
 namespace App\Schedule;
 
-use App\Element\Element;
 use DateTimeImmutable;
 
 final readonly class ScheduleAssignment
 {
+    /**
+     * @param list<string> $path
+     */
     public function __construct(
         private int $id,
-        private Element $element,
+        private string $name,
+        private string $kind,
+        private array $path,
         private DateTimeImmutable $scheduledDate,
         private int $position,
     ) {}
@@ -19,9 +23,22 @@ final readonly class ScheduleAssignment
         return $this->id;
     }
 
-    public function getElement(): Element
+    public function getName(): string
     {
-        return $this->element;
+        return $this->name;
+    }
+
+    public function getKind(): string
+    {
+        return $this->kind;
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getPath(): array
+    {
+        return $this->path;
     }
 
     public function getScheduledDate(): DateTimeImmutable
diff --git a/backend/app/Schedule/ScheduleAssignmentModel.php b/backend/app/Schedule/ScheduleAssignmentModel.php
index 782b906..f0f33df 100644
--- a/backend/app/Schedule/ScheduleAssignmentModel.php
+++ b/backend/app/Schedule/ScheduleAssignmentModel.php
@@ -9,7 +9,9 @@ use Illuminate\Database\Eloquent\Model;
 /**
  * @property int $id
  * @property int $schedule_id
- * @property int $element_id
+ * @property string $element_name
+ * @property string $element_kind
+ * @property list<string> $element_path
  * @property string $scheduled_date
  * @property int $position
  *
@@ -21,7 +23,9 @@ use Illuminate\Database\Eloquent\Model;
  */
 #[Fillable([
     'schedule_id',
-    'element_id',
+    'element_name',
+    'element_kind',
+    'element_path',
     'scheduled_date',
     'position',
 ])]
@@ -38,7 +42,7 @@ class ScheduleAssignmentModel extends Model
     {
         return [
             'schedule_id' => 'integer',
-            'element_id' => 'integer',
+            'element_path' => 'array',
             'position' => 'integer',
         ];
     }
diff --git a/backend/app/Schedule/ScheduleModel.php b/backend/app/Schedule/ScheduleModel.php
index 6d0132d..f19fb97 100644
--- a/backend/app/Schedule/ScheduleModel.php
+++ b/backend/app/Schedule/ScheduleModel.php
@@ -9,7 +9,7 @@ use Illuminate\Database\Eloquent\Model;
 /**
  * @property int $id
  * @property int $user_id
- * @property int $set_id
+ * @property string $set_name
  * @property string $element_kind
  * @property string $start_date
  * @property string $target_date
@@ -22,7 +22,7 @@ use Illuminate\Database\Eloquent\Model;
  */
 #[Fillable([
     'user_id',
-    'set_id',
+    'set_name',
     'element_kind',
     'start_date',
     'target_date',
@@ -40,7 +40,6 @@ class ScheduleModel extends Model
     {
         return [
             'user_id' => 'integer',
-            'set_id' => 'integer',
         ];
     }
 }
diff --git a/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php b/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
index c41b19c..1759d73 100644
--- a/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
+++ b/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
@@ -70,7 +70,7 @@ class CreateSchedule
 
         return $this->scheduleRepository->create(new CreateScheduleDto(
             user: $request->user,
-            set: $set,
+            setName: $set->getName(),
             elementKind: $request->elementKind,
             startDate: $startDate,
             targetDate: $targetDate,
@@ -153,7 +153,9 @@ class CreateSchedule
                 dayCount: $dayCount,
             );
             $assignments[] = new CreateScheduleAssignmentDto(
-                element: $element,
+                name: $element->getName(),
+                kind: $element->getKind(),
+                path: $this->elementPath($element),
                 scheduledDate: $startDate->modify("+{$dayIndex} days"),
                 position: $index + 1,
             );
@@ -162,6 +164,22 @@ class CreateSchedule
         return $assignments;
     }
 
+    /**
+     * @return list<string>
+     */
+    private function elementPath(Element $element): array
+    {
+        $path = [];
+        $currentElement = $element;
+
+        while ($currentElement !== null) {
+            array_unshift($path, $currentElement->getName());
+            $currentElement = $currentElement->getParentElement();
+        }
+
+        return $path;
+    }
+
     private function dayIndex(
         int $elementIndex,
         int $elementCount,
diff --git a/backend/database/migrations/2026_08_10_000000_create_schedules_table.php b/backend/database/migrations/2026_08_10_000000_create_schedules_table.php
index cfe3028..390b246 100644
--- a/backend/database/migrations/2026_08_10_000000_create_schedules_table.php
+++ b/backend/database/migrations/2026_08_10_000000_create_schedules_table.php
@@ -13,9 +13,7 @@ return new class extends Migration
             $table->foreignId('user_id')
                 ->constrained('users')
                 ->restrictOnDelete();
-            $table->foreignId('set_id')
-                ->constrained('sets')
-                ->restrictOnDelete();
+            $table->string('set_name');
             $table->string('element_kind');
             $table->date('start_date');
             $table->date('target_date');
diff --git a/backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php b/backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php
index 88c05b3..b52c60a 100644
--- a/backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php
+++ b/backend/database/migrations/2026_08_10_000001_create_schedule_assignments_table.php
@@ -15,12 +15,11 @@ return new class extends Migration
                 $table->foreignId('schedule_id')
                     ->constrained('schedules')
                     ->cascadeOnDelete();
-                $table->foreignId('element_id')
-                    ->constrained('elements')
-                    ->restrictOnDelete();
+                $table->string('element_name');
+                $table->string('element_kind');
+                $table->json('element_path');
                 $table->date('scheduled_date');
                 $table->unsignedInteger('position');
-                $table->unique(['schedule_id', 'element_id']);
                 $table->unique(['schedule_id', 'position']);
                 $table->index([
                     'schedule_id',
diff --git a/frontend/website/cypress/e2e/set-scheduling.cy.ts b/frontend/website/cypress/e2e/set-scheduling.cy.ts
index 824024d..6ebe605 100644
--- a/frontend/website/cypress/e2e/set-scheduling.cy.ts
+++ b/frontend/website/cypress/e2e/set-scheduling.cy.ts
@@ -45,7 +45,7 @@ const bibleLayout = {
 const scheduleDetail = {
   schedule: {
     id: 73,
-    set: { id: 41, name: 'Bible' },
+    set: { name: 'Bible' },
     elementKind: 'chapter',
     startDate: '2026-08-10',
     targetDate: '2026-08-12',
@@ -55,8 +55,8 @@ const scheduleDetail = {
         date: '2026-08-10',
         assignments: [
           {
+            id: 1,
             element: {
-              id: 4,
               name: 'Chapter 1',
               kind: 'chapter',
               path: ['Genesis', 'Creation', 'Chapter 1'],
@@ -69,8 +69,8 @@ const scheduleDetail = {
         date: '2026-08-12',
         assignments: [
           {
+            id: 2,
             element: {
-              id: 5,
               name: 'Chapter 1',
               kind: 'chapter',
               path: ['Exodus', 'Chapter 1'],
@@ -213,7 +213,7 @@ describe('set scheduling', () => {
           schedules: [
             {
               id: 73,
-              set: { id: 41, name: 'Bible' },
+              set: { name: 'Bible' },
               elementKind: 'chapter',
               startDate: '2026-08-10',
               targetDate: '2026-08-12',
diff --git a/frontend/website/src/stores/schedules.ts b/frontend/website/src/stores/schedules.ts
index 79f27a1..d5b46a2 100644
--- a/frontend/website/src/stores/schedules.ts
+++ b/frontend/website/src/stores/schedules.ts
@@ -9,7 +9,6 @@ const isoDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/)
 export const scheduleSummarySchema = z.object({
   id: z.number().int().positive(),
   set: z.object({
-    id: z.number().int().positive(),
     name: z.string().min(1),
   }),
   elementKind: z.string().min(1),
@@ -19,8 +18,8 @@ export const scheduleSummarySchema = z.object({
 })
 
 const scheduleAssignmentSchema = z.object({
+  id: z.number().int().positive(),
   element: z.object({
-    id: z.number().int().positive(),
     name: z.string().min(1),
     kind: z.string().min(1),
     path: z.array(z.string().min(1)).min(1),
diff --git a/frontend/website/src/views/ScheduleDetailView.vue b/frontend/website/src/views/ScheduleDetailView.vue
index 0471be6..fe430b4 100644
--- a/frontend/website/src/views/ScheduleDetailView.vue
+++ b/frontend/website/src/views/ScheduleDetailView.vue
@@ -117,7 +117,7 @@ function pluralKind(kind: string, count: number): string {
             <p v-if="day.assignments.length === 0" class="rest-day">Rest day</p>
 
             <ul v-else class="assignment-list">
-              <li v-for="assignment in day.assignments" :key="assignment.element.id">
+              <li v-for="assignment in day.assignments" :key="assignment.id">
                 <span class="assignment-path">{{ assignment.element.path.join(' / ') }}</span>
                 <span class="assignment-kind">{{ humanizeKind(assignment.element.kind) }}</span>
               </li>

From 0e8d45a408bde7bddcf94649e04861b69c19ebdb Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Mon, 10 Aug 2026 22:36:25 +0300
Subject: [PATCH 09/25] document stable schedule snapshots

---
 ai/shared.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/ai/shared.md b/ai/shared.md
index b696249..a6fe77d 100644
--- a/ai/shared.md
+++ b/ai/shared.md
@@ -12,6 +12,11 @@ these rules.
 - Schedules target whole sets. Users choose an element kind as the assignment
   granularity. To schedule a subset, create a separate named set containing
   that subset.
+- Schedules are immutable historical snapshots. Copy the set name and each
+  assignment's name, kind, and full path when creating a schedule.
+- Persisted schedules must not reference their source set, and persisted
+  assignments must not reference their source elements. Later source edits or
+  deletions must not change an existing schedule.
 - Schedule recalculation must preserve completed work while redistributing
   unfinished assignments across the remaining dates.
 - Planned features in `README.md` are future ideas, not authorized scope.

From 7e8850b1b2db6a578544c5cf922b54e91da0824f Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 22:46:29 +0300
Subject: [PATCH 10/25] test explicit set levels

---
 .../Set/EloquentSetLevelRepositoryTest.php    | 92 +++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 backend/tests/Feature/Set/EloquentSetLevelRepositoryTest.php

diff --git a/backend/tests/Feature/Set/EloquentSetLevelRepositoryTest.php b/backend/tests/Feature/Set/EloquentSetLevelRepositoryTest.php
new file mode 100644
index 0000000..29f1c40
--- /dev/null
+++ b/backend/tests/Feature/Set/EloquentSetLevelRepositoryTest.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Tests\Feature\Set;
+
+use App\Set\CreateSetDto;
+use App\Set\CreateSetLevelDto;
+use App\Set\Set;
+use App\Set\SetLevelRepository;
+use App\Set\SetRepository;
+use App\Shared\ValueObject\EmailAddress;
+use App\User\CreateUserDto;
+use App\User\UserRepository;
+use DomainException;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class EloquentSetLevelRepositoryTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function testItCreatesOrderedLevelsWithinEachSet(): void
+    {
+        $bible = $this->createSet('Bible');
+        $course = $this->createSet('Course');
+        $repository = app(SetLevelRepository::class);
+
+        $book = $repository->create(new CreateSetLevelDto(
+            set: $bible,
+            kind: 'book',
+        ));
+        $portion = $repository->create(new CreateSetLevelDto(
+            set: $bible,
+            kind: 'portion',
+        ));
+        $module = $repository->create(new CreateSetLevelDto(
+            set: $course,
+            kind: 'module',
+        ));
+
+        $this->assertSame(0, $book->getDepth());
+        $this->assertSame(1, $portion->getDepth());
+        $this->assertSame(0, $module->getDepth());
+        $this->assertSame(
+            ['book', 'portion'],
+            array_map(function ($level): string {
+                return $level->getKind();
+            }, $repository->findBySet($bible)),
+        );
+        $this->assertSame(
+            $portion->getId(),
+            $repository->find($portion->getId())?->getId(),
+        );
+        $this->assertDatabaseHas('set_levels', [
+            'set_id' => $bible->getId(),
+            'kind' => 'portion',
+            'depth' => 1,
+        ]);
+    }
+
+    public function testItRejectsARepeatedKindWithinASet(): void
+    {
+        $set = $this->createSet('Bible');
+        $repository = app(SetLevelRepository::class);
+        $repository->create(new CreateSetLevelDto(
+            set: $set,
+            kind: 'book',
+        ));
+
+        $this->expectException(DomainException::class);
+        $this->expectExceptionMessage(
+            'level kind must be unique within set',
+        );
+
+        $repository->create(new CreateSetLevelDto(
+            set: $set,
+            kind: 'book',
+        ));
+    }
+
+    private function createSet(string $name): Set
+    {
+        $user = app(UserRepository::class)->create(new CreateUserDto(
+            email: new EmailAddress(strtolower($name).'@example.com'),
+            passwordHash: 'hashed-password',
+        ));
+
+        return app(SetRepository::class)->create(new CreateSetDto(
+            name: $name,
+            creator: $user,
+        ));
+    }
+}

From 0d102fcee01a61b3952219b737fe2758fd160b1f Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 22:47:34 +0300
Subject: [PATCH 11/25] add explicit set levels

---
 backend/app/Providers/AppServiceProvider.php  |  6 ++
 backend/app/Set/CreateSetLevelDto.php         | 11 +++
 .../app/Set/EloquentSetLevelRepository.php    | 88 +++++++++++++++++++
 backend/app/Set/SetLevel.php                  | 33 +++++++
 backend/app/Set/SetLevelModel.php             | 38 ++++++++
 backend/app/Set/SetLevelRepository.php        | 20 +++++
 ...6_08_07_000000_create_set_levels_table.php | 27 ++++++
 7 files changed, 223 insertions(+)
 create mode 100644 backend/app/Set/CreateSetLevelDto.php
 create mode 100644 backend/app/Set/EloquentSetLevelRepository.php
 create mode 100644 backend/app/Set/SetLevel.php
 create mode 100644 backend/app/Set/SetLevelModel.php
 create mode 100644 backend/app/Set/SetLevelRepository.php
 create mode 100644 backend/database/migrations/2026_08_07_000000_create_set_levels_table.php

diff --git a/backend/app/Providers/AppServiceProvider.php b/backend/app/Providers/AppServiceProvider.php
index d0d019d..aaf8dfd 100644
--- a/backend/app/Providers/AppServiceProvider.php
+++ b/backend/app/Providers/AppServiceProvider.php
@@ -19,7 +19,9 @@ use App\Email\LaravelEmailFactory;
 use App\Element\ElementRepository;
 use App\Element\EloquentElementRepository;
 use App\Set\EloquentSetRepository;
+use App\Set\EloquentSetLevelRepository;
 use App\Set\SetRepository;
+use App\Set\SetLevelRepository;
 use App\Schedule\EloquentScheduleRepository;
 use App\Schedule\ScheduleRepository;
 use App\User\EloquentUserRepository;
@@ -55,6 +57,10 @@ class AppServiceProvider extends ServiceProvider
             SetRepository::class,
             EloquentSetRepository::class,
         );
+        $this->app->bind(
+            SetLevelRepository::class,
+            EloquentSetLevelRepository::class,
+        );
         $this->app->bind(
             ElementRepository::class,
             EloquentElementRepository::class,
diff --git a/backend/app/Set/CreateSetLevelDto.php b/backend/app/Set/CreateSetLevelDto.php
new file mode 100644
index 0000000..1920a50
--- /dev/null
+++ b/backend/app/Set/CreateSetLevelDto.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Set;
+
+final readonly class CreateSetLevelDto
+{
+    public function __construct(
+        public Set $set,
+        public string $kind,
+    ) {}
+}
diff --git a/backend/app/Set/EloquentSetLevelRepository.php b/backend/app/Set/EloquentSetLevelRepository.php
new file mode 100644
index 0000000..6b1fc12
--- /dev/null
+++ b/backend/app/Set/EloquentSetLevelRepository.php
@@ -0,0 +1,88 @@
+<?php
+
+namespace App\Set;
+
+use DomainException;
+use RuntimeException;
+
+class EloquentSetLevelRepository implements SetLevelRepository
+{
+    public function __construct(
+        private SetRepository $setRepository,
+    ) {}
+
+    public function create(CreateSetLevelDto $dto): SetLevel
+    {
+        $kindExists = SetLevelModel::query()
+            ->where('set_id', $dto->set->getId())
+            ->where('kind', $dto->kind)
+            ->exists();
+        if ($kindExists) {
+            throw new DomainException(
+                'level kind must be unique within set',
+            );
+        }
+
+        $currentMaximum = SetLevelModel::query()
+            ->where('set_id', $dto->set->getId())
+            ->max('depth');
+        $depth = $currentMaximum === null
+            ? 0
+            : (int) $currentMaximum + 1;
+        $model = SetLevelModel::create([
+            'set_id' => $dto->set->getId(),
+            'kind' => $dto->kind,
+            'depth' => $depth,
+        ]);
+
+        return new SetLevel(
+            id: $model->id,
+            set: $dto->set,
+            kind: $model->kind,
+            depth: $model->depth,
+        );
+    }
+
+    public function find(int $id): ?SetLevel
+    {
+        $model = SetLevelModel::find($id);
+
+        return $model === null ? null : $this->toDomain($model);
+    }
+
+    public function findBySet(Set $set): array
+    {
+        $models = SetLevelModel::query()
+            ->where('set_id', $set->getId())
+            ->orderBy('depth')
+            ->orderBy('id')
+            ->get();
+        $levels = [];
+
+        foreach ($models as $model) {
+            $levels[] = new SetLevel(
+                id: $model->id,
+                set: $set,
+                kind: $model->kind,
+                depth: $model->depth,
+            );
+        }
+
+        return $levels;
+    }
+
+    private function toDomain(SetLevelModel $model): SetLevel
+    {
+        $set = $this->setRepository->find($model->set_id);
+        if ($set === null) {
+            throw new RuntimeException('set level set not found');
+        }
+
+        return new SetLevel(
+            id: $model->id,
+            set: $set,
+            kind: $model->kind,
+            depth: $model->depth,
+        );
+    }
+}
diff --git a/backend/app/Set/SetLevel.php b/backend/app/Set/SetLevel.php
new file mode 100644
index 0000000..23b5a99
--- /dev/null
+++ b/backend/app/Set/SetLevel.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Set;
+
+final readonly class SetLevel
+{
+    public function __construct(
+        private int $id,
+        private Set $set,
+        private string $kind,
+        private int $depth,
+    ) {}
+
+    public function getId(): int
+    {
+        return $this->id;
+    }
+
+    public function getSet(): Set
+    {
+        return $this->set;
+    }
+
+    public function getKind(): string
+    {
+        return $this->kind;
+    }
+
+    public function getDepth(): int
+    {
+        return $this->depth;
+    }
+}
diff --git a/backend/app/Set/SetLevelModel.php b/backend/app/Set/SetLevelModel.php
new file mode 100644
index 0000000..50daf3e
--- /dev/null
+++ b/backend/app/Set/SetLevelModel.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Set;
+
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+
+/**
+ * @property int $id
+ * @property int $set_id
+ * @property string $kind
+ * @property int $depth
+ *
+ * @method static Builder<static>|SetLevelModel newModelQuery()
+ * @method static Builder<static>|SetLevelModel newQuery()
+ * @method static Builder<static>|SetLevelModel query()
+ *
+ * @mixin \Eloquent
+ */
+#[Fillable(['set_id', 'kind', 'depth'])]
+class SetLevelModel extends Model
+{
+    protected $table = 'set_levels';
+
+    public $timestamps = false;
+
+    /**
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'set_id' => 'integer',
+            'depth' => 'integer',
+        ];
+    }
+}
diff --git a/backend/app/Set/SetLevelRepository.php b/backend/app/Set/SetLevelRepository.php
new file mode 100644
index 0000000..ba4b68c
--- /dev/null
+++ b/backend/app/Set/SetLevelRepository.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Set;
+
+use DomainException;
+
+interface SetLevelRepository
+{
+    /**
+     * @throws DomainException
+     */
+    public function create(CreateSetLevelDto $dto): SetLevel;
+
+    public function find(int $id): ?SetLevel;
+
+    /**
+     * @return list<SetLevel>
+     */
+    public function findBySet(Set $set): array;
+}
diff --git a/backend/database/migrations/2026_08_07_000000_create_set_levels_table.php b/backend/database/migrations/2026_08_07_000000_create_set_levels_table.php
new file mode 100644
index 0000000..552c31a
--- /dev/null
+++ b/backend/database/migrations/2026_08_07_000000_create_set_levels_table.php
@@ -0,0 +1,27 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('set_levels', function (Blueprint $table): void {
+            $table->id();
+            $table->foreignId('set_id')
+                ->constrained('sets')
+                ->cascadeOnDelete();
+            $table->string('kind');
+            $table->unsignedInteger('depth');
+            $table->unique(['set_id', 'kind']);
+            $table->unique(['set_id', 'depth']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('set_levels');
+    }
+};

From 25495b6c4df31a9496cc341860eaaaefa31e6f21 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 22:48:53 +0300
Subject: [PATCH 12/25] test enforced element levels

---
 .../Element/EloquentElementRepositoryTest.php | 116 +++++++++++++-----
 backend/tests/Unit/Element/ElementTest.php    |  20 ++-
 2 files changed, 100 insertions(+), 36 deletions(-)

diff --git a/backend/tests/Feature/Element/EloquentElementRepositoryTest.php b/backend/tests/Feature/Element/EloquentElementRepositoryTest.php
index 76766c5..9cc6020 100644
--- a/backend/tests/Feature/Element/EloquentElementRepositoryTest.php
+++ b/backend/tests/Feature/Element/EloquentElementRepositoryTest.php
@@ -5,7 +5,10 @@ namespace Tests\Feature\Element;
 use App\Element\CreateElementDto;
 use App\Element\ElementRepository;
 use App\Set\CreateSetDto;
+use App\Set\CreateSetLevelDto;
 use App\Set\Set;
+use App\Set\SetLevel;
+use App\Set\SetLevelRepository;
 use App\Set\SetRepository;
 use App\Shared\ValueObject\EmailAddress;
 use App\User\CreateUserDto;
@@ -22,28 +25,26 @@ class EloquentElementRepositoryTest extends TestCase
     {
         $set = $this->createSet('Bible');
         $repository = app(ElementRepository::class);
+        $bookLevel = $this->createLevel($set, 'book');
+        $portionLevel = $this->createLevel($set, 'portion');
         $genesisBook = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Genesis',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $exodusBook = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Exodus',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $genesisPortion = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Genesis',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesisBook,
         ));
         $noahPortion = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Noah',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesisBook,
         ));
 
@@ -53,9 +54,8 @@ class EloquentElementRepositoryTest extends TestCase
         $this->assertSame(2, $noahPortion->getPosition());
         $this->assertDatabaseHas('elements', [
             'id' => $genesisPortion->getId(),
-            'set_id' => $set->getId(),
+            'set_level_id' => $portionLevel->getId(),
             'name' => 'Genesis',
-            'kind' => 'portion',
             'parent_element_id' => $genesisBook->getId(),
             'position' => 1,
         ]);
@@ -65,6 +65,10 @@ class EloquentElementRepositoryTest extends TestCase
         $this->assertNotNull($foundElement);
         $this->assertSame('Noah', $foundElement->getName());
         $this->assertSame('portion', $foundElement->getKind());
+        $this->assertSame(
+            $portionLevel->getId(),
+            $foundElement->getLevel()->getId(),
+        );
         $this->assertSame($set->getId(), $foundElement->getSet()->getId());
         $this->assertSame(
             $genesisBook->getId(),
@@ -77,10 +81,11 @@ class EloquentElementRepositoryTest extends TestCase
         $bible = $this->createSet('Bible');
         $course = $this->createSet('Course');
         $repository = app(ElementRepository::class);
+        $bookLevel = $this->createLevel($bible, 'book');
+        $moduleLevel = $this->createLevel($course, 'module');
         $book = $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Genesis',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
 
@@ -90,9 +95,51 @@ class EloquentElementRepositoryTest extends TestCase
         );
 
         $repository->create(new CreateElementDto(
-            set: $course,
             name: 'Invalid lesson',
-            kind: 'lesson',
+            level: $moduleLevel,
+            parentElement: $book,
+        ));
+    }
+
+    public function testItRejectsARootOutsideTheFirstLevel(): void
+    {
+        $set = $this->createSet('Bible');
+        $this->createLevel($set, 'book');
+        $portionLevel = $this->createLevel($set, 'portion');
+
+        $this->expectException(DomainException::class);
+        $this->expectExceptionMessage(
+            'root element must use the first set level',
+        );
+
+        app(ElementRepository::class)->create(new CreateElementDto(
+            name: 'Creation',
+            level: $portionLevel,
+            parentElement: null,
+        ));
+    }
+
+    public function testItRejectsAChildOutsideTheNextLevel(): void
+    {
+        $set = $this->createSet('Bible');
+        $bookLevel = $this->createLevel($set, 'book');
+        $this->createLevel($set, 'portion');
+        $chapterLevel = $this->createLevel($set, 'chapter');
+        $repository = app(ElementRepository::class);
+        $book = $repository->create(new CreateElementDto(
+            name: 'Genesis',
+            level: $bookLevel,
+            parentElement: null,
+        ));
+
+        $this->expectException(DomainException::class);
+        $this->expectExceptionMessage(
+            'child element must use the next set level',
+        );
+
+        $repository->create(new CreateElementDto(
+            name: 'Chapter 1',
+            level: $chapterLevel,
             parentElement: $book,
         ));
     }
@@ -102,40 +149,37 @@ class EloquentElementRepositoryTest extends TestCase
         $bible = $this->createSet('Bible');
         $course = $this->createSet('Course');
         $repository = app(ElementRepository::class);
+        $bookLevel = $this->createLevel($bible, 'book');
+        $portionLevel = $this->createLevel($bible, 'portion');
+        $moduleLevel = $this->createLevel($course, 'module');
         $genesisBook = $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Genesis',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $exodusBook = $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Exodus',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $repository->create(new CreateElementDto(
-            set: $course,
             name: 'Module 1',
-            kind: 'module',
+            level: $moduleLevel,
             parentElement: null,
         ));
         $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Genesis',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesisBook,
         ));
         $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Noah',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesisBook,
         ));
         $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Shemot',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $exodusBook,
         ));
 
@@ -161,22 +205,22 @@ class EloquentElementRepositoryTest extends TestCase
         $bible = $this->createSet('Bible');
         $course = $this->createSet('Course');
         $repository = app(ElementRepository::class);
+        $bookLevel = $this->createLevel($bible, 'book');
+        $portionLevel = $this->createLevel($bible, 'portion');
+        $moduleLevel = $this->createLevel($course, 'module');
         $genesis = $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Genesis',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $repository->create(new CreateElementDto(
-            set: $bible,
             name: 'Creation',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesis,
         ));
         $repository->create(new CreateElementDto(
-            set: $course,
             name: 'Foundations',
-            kind: 'module',
+            level: $moduleLevel,
             parentElement: null,
         ));
 
@@ -207,4 +251,12 @@ class EloquentElementRepositoryTest extends TestCase
             creator: $creator,
         ));
     }
+
+    private function createLevel(Set $set, string $kind): SetLevel
+    {
+        return app(SetLevelRepository::class)->create(new CreateSetLevelDto(
+            set: $set,
+            kind: $kind,
+        ));
+    }
 }
diff --git a/backend/tests/Unit/Element/ElementTest.php b/backend/tests/Unit/Element/ElementTest.php
index 1a99b31..3acd12d 100644
--- a/backend/tests/Unit/Element/ElementTest.php
+++ b/backend/tests/Unit/Element/ElementTest.php
@@ -4,6 +4,7 @@ namespace Tests\Unit\Element;
 
 use App\Element\Element;
 use App\Set\Set;
+use App\Set\SetLevel;
 use App\Shared\ValueObject\EmailAddress;
 use App\User\User;
 use PHPUnit\Framework\TestCase;
@@ -22,19 +23,29 @@ class ElementTest extends TestCase
             name: 'Bible',
             creator: $creator,
         );
+        $bookLevel = new SetLevel(
+            id: 31,
+            set: $set,
+            kind: 'book',
+            depth: 0,
+        );
+        $portionLevel = new SetLevel(
+            id: 32,
+            set: $set,
+            kind: 'portion',
+            depth: 1,
+        );
         $parentElement = new Element(
             id: 21,
             name: 'Genesis',
-            kind: 'book',
-            set: $set,
+            level: $bookLevel,
             parentElement: null,
             position: 1,
         );
         $element = new Element(
             id: 22,
             name: 'Genesis',
-            kind: 'portion',
-            set: $set,
+            level: $portionLevel,
             parentElement: $parentElement,
             position: 2,
         );
@@ -42,6 +53,7 @@ class ElementTest extends TestCase
         $this->assertSame(22, $element->getId());
         $this->assertSame('Genesis', $element->getName());
         $this->assertSame('portion', $element->getKind());
+        $this->assertSame($portionLevel, $element->getLevel());
         $this->assertSame($set, $element->getSet());
         $this->assertSame($parentElement, $element->getParentElement());
         $this->assertSame(2, $element->getPosition());

From 99e1ba051c9d04566b1c34adf7d4a1f2c97fb165 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 22:50:07 +0300
Subject: [PATCH 13/25] enforce element level hierarchy

---
 backend/app/Element/CreateElementDto.php      |  5 +-
 backend/app/Element/Element.php               | 13 ++-
 backend/app/Element/ElementModel.php          |  8 +-
 .../app/Element/EloquentElementRepository.php | 91 +++++++++++++------
 ...026_08_08_000000_create_elements_table.php |  7 +-
 5 files changed, 80 insertions(+), 44 deletions(-)

diff --git a/backend/app/Element/CreateElementDto.php b/backend/app/Element/CreateElementDto.php
index 6f7df77..d8a9fdc 100644
--- a/backend/app/Element/CreateElementDto.php
+++ b/backend/app/Element/CreateElementDto.php
@@ -2,14 +2,13 @@
 
 namespace App\Element;
 
-use App\Set\Set;
+use App\Set\SetLevel;
 
 final readonly class CreateElementDto
 {
     public function __construct(
-        public Set $set,
         public string $name,
-        public string $kind,
+        public SetLevel $level,
         public ?Element $parentElement,
     ) {}
 }
diff --git a/backend/app/Element/Element.php b/backend/app/Element/Element.php
index 5e4c6bd..5eb6fe8 100644
--- a/backend/app/Element/Element.php
+++ b/backend/app/Element/Element.php
@@ -3,14 +3,14 @@
 namespace App\Element;
 
 use App\Set\Set;
+use App\Set\SetLevel;
 
 final readonly class Element
 {
     public function __construct(
         private int $id,
         private string $name,
-        private string $kind,
-        private Set $set,
+        private SetLevel $level,
         private ?Element $parentElement,
         private int $position,
     ) {}
@@ -27,12 +27,17 @@ final readonly class Element
 
     public function getKind(): string
     {
-        return $this->kind;
+        return $this->level->getKind();
+    }
+
+    public function getLevel(): SetLevel
+    {
+        return $this->level;
     }
 
     public function getSet(): Set
     {
-        return $this->set;
+        return $this->level->getSet();
     }
 
     public function getParentElement(): ?Element
diff --git a/backend/app/Element/ElementModel.php b/backend/app/Element/ElementModel.php
index 6eb345d..5a228d7 100644
--- a/backend/app/Element/ElementModel.php
+++ b/backend/app/Element/ElementModel.php
@@ -8,9 +8,8 @@ use Illuminate\Database\Eloquent\Model;
 
 /**
  * @property int $id
- * @property int $set_id
+ * @property int $set_level_id
  * @property string $name
- * @property string $kind
  * @property int|null $parent_element_id
  * @property int $position
  *
@@ -21,9 +20,8 @@ use Illuminate\Database\Eloquent\Model;
  * @mixin \Eloquent
  */
 #[Fillable([
-    'set_id',
+    'set_level_id',
     'name',
-    'kind',
     'parent_element_id',
     'position',
 ])]
@@ -39,7 +37,7 @@ class ElementModel extends Model
     protected function casts(): array
     {
         return [
-            'set_id' => 'integer',
+            'set_level_id' => 'integer',
             'parent_element_id' => 'integer',
             'position' => 'integer',
         ];
diff --git a/backend/app/Element/EloquentElementRepository.php b/backend/app/Element/EloquentElementRepository.php
index 1f30e24..fd12d58 100644
--- a/backend/app/Element/EloquentElementRepository.php
+++ b/backend/app/Element/EloquentElementRepository.php
@@ -3,27 +3,27 @@
 namespace App\Element;
 
 use App\Set\Set;
-use App\Set\SetRepository;
+use App\Set\SetLevel;
+use App\Set\SetLevelRepository;
 use DomainException;
 use RuntimeException;
 
 class EloquentElementRepository implements ElementRepository
 {
     public function __construct(
-        private SetRepository $setRepository,
+        private SetLevelRepository $setLevelRepository,
     ) {}
 
     public function create(CreateElementDto $dto): Element
     {
-        $this->validateParentSet($dto);
+        $this->validateLevel($dto);
         $position = $this->nextPosition(
-            $dto->set,
+            $dto->level,
             $dto->parentElement,
         );
         $model = ElementModel::create([
-            'set_id' => $dto->set->getId(),
+            'set_level_id' => $dto->level->getId(),
             'name' => $dto->name,
-            'kind' => $dto->kind,
             'parent_element_id' => $dto->parentElement?->getId(),
             'position' => $position,
         ]);
@@ -31,8 +31,7 @@ class EloquentElementRepository implements ElementRepository
         return new Element(
             id: $model->id,
             name: $model->name,
-            kind: $model->kind,
-            set: $dto->set,
+            level: $dto->level,
             parentElement: $dto->parentElement,
             position: $model->position,
         );
@@ -47,14 +46,27 @@ class EloquentElementRepository implements ElementRepository
 
     public function findBySet(Set $set): array
     {
+        $levelsById = [];
+        foreach ($this->setLevelRepository->findBySet($set) as $level) {
+            $levelsById[$level->getId()] = $level;
+        }
+        if ($levelsById === []) {
+            return [];
+        }
+
         $models = ElementModel::query()
-            ->where('set_id', $set->getId())
+            ->whereIn('set_level_id', array_keys($levelsById))
             ->orderBy('id')
             ->get();
         $elements = [];
         $elementsById = [];
 
         foreach ($models as $model) {
+            $level = $levelsById[$model->set_level_id] ?? null;
+            if ($level === null) {
+                throw new RuntimeException('element level not found');
+            }
+
             $parentElement = null;
             if ($model->parent_element_id !== null) {
                 $parentElement = $elementsById[$model->parent_element_id]
@@ -66,7 +78,7 @@ class EloquentElementRepository implements ElementRepository
 
             $element = $this->toDomainWithRelations(
                 model: $model,
-                set: $set,
+                level: $level,
                 parentElement: $parentElement,
             );
             $elements[] = $element;
@@ -78,8 +90,14 @@ class EloquentElementRepository implements ElementRepository
 
     public function findTopLevelBySet(Set $set): array
     {
+        $levels = $this->setLevelRepository->findBySet($set);
+        if ($levels === []) {
+            return [];
+        }
+
+        $topLevel = $levels[0];
         $models = ElementModel::query()
-            ->where('set_id', $set->getId())
+            ->where('set_level_id', $topLevel->getId())
             ->whereNull('parent_element_id')
             ->orderBy('position')
             ->orderBy('id')
@@ -89,7 +107,7 @@ class EloquentElementRepository implements ElementRepository
         foreach ($models as $model) {
             $elements[] = $this->toDomainWithRelations(
                 model: $model,
-                set: $set,
+                level: $topLevel,
                 parentElement: null,
             );
         }
@@ -100,7 +118,6 @@ class EloquentElementRepository implements ElementRepository
     public function findByParentElement(Element $parentElement): array
     {
         $models = ElementModel::query()
-            ->where('set_id', $parentElement->getSet()->getId())
             ->where('parent_element_id', $parentElement->getId())
             ->orderBy('position')
             ->orderBy('id')
@@ -108,9 +125,10 @@ class EloquentElementRepository implements ElementRepository
         $elements = [];
 
         foreach ($models as $model) {
+            $level = $this->findLevel($model->set_level_id);
             $elements[] = $this->toDomainWithRelations(
                 model: $model,
-                set: $parentElement->getSet(),
+                level: $level,
                 parentElement: $parentElement,
             );
         }
@@ -121,26 +139,44 @@ class EloquentElementRepository implements ElementRepository
     /**
      * @throws DomainException
      */
-    private function validateParentSet(CreateElementDto $dto): void
+    private function validateLevel(CreateElementDto $dto): void
     {
         $parentElement = $dto->parentElement;
         if ($parentElement === null) {
+            if ($dto->level->getDepth() !== 0) {
+                throw new DomainException(
+                    'root element must use the first set level',
+                );
+            }
+
             return;
         }
 
-        if ($parentElement->getSet()->getId() !== $dto->set->getId()) {
+        if (
+            $parentElement->getSet()->getId()
+            !== $dto->level->getSet()->getId()
+        ) {
             throw new DomainException(
                 'parent element must belong to the same set',
             );
         }
+
+        if (
+            $dto->level->getDepth()
+            !== $parentElement->getLevel()->getDepth() + 1
+        ) {
+            throw new DomainException(
+                'child element must use the next set level',
+            );
+        }
     }
 
     private function nextPosition(
-        Set $set,
+        SetLevel $level,
         ?Element $parentElement,
     ): int {
         $query = ElementModel::query()
-            ->where('set_id', $set->getId());
+            ->where('set_level_id', $level->getId());
         if ($parentElement === null) {
             $query->whereNull('parent_element_id');
         } else {
@@ -157,7 +193,7 @@ class EloquentElementRepository implements ElementRepository
 
     private function toDomain(ElementModel $model): Element
     {
-        $set = $this->findSet($model->set_id);
+        $level = $this->findLevel($model->set_level_id);
 
         $parentElement = null;
         if ($model->parent_element_id !== null) {
@@ -169,33 +205,32 @@ class EloquentElementRepository implements ElementRepository
 
         return $this->toDomainWithRelations(
             model: $model,
-            set: $set,
+            level: $level,
             parentElement: $parentElement,
         );
     }
 
     private function toDomainWithRelations(
         ElementModel $model,
-        Set $set,
+        SetLevel $level,
         ?Element $parentElement,
     ): Element {
         return new Element(
             id: $model->id,
             name: $model->name,
-            kind: $model->kind,
-            set: $set,
+            level: $level,
             parentElement: $parentElement,
             position: $model->position,
         );
     }
 
-    private function findSet(int $id): Set
+    private function findLevel(int $id): SetLevel
     {
-        $set = $this->setRepository->find($id);
-        if ($set !== null) {
-            return $set;
+        $level = $this->setLevelRepository->find($id);
+        if ($level !== null) {
+            return $level;
         }
 
-        throw new RuntimeException('element set not found');
+        throw new RuntimeException('element level not found');
     }
 }
diff --git a/backend/database/migrations/2026_08_08_000000_create_elements_table.php b/backend/database/migrations/2026_08_08_000000_create_elements_table.php
index 196c2c5..04fe1d4 100644
--- a/backend/database/migrations/2026_08_08_000000_create_elements_table.php
+++ b/backend/database/migrations/2026_08_08_000000_create_elements_table.php
@@ -10,18 +10,17 @@ return new class extends Migration
     {
         Schema::create('elements', function (Blueprint $table): void {
             $table->id();
-            $table->foreignId('set_id')
-                ->constrained('sets')
+            $table->foreignId('set_level_id')
+                ->constrained('set_levels')
                 ->restrictOnDelete();
             $table->string('name');
-            $table->string('kind');
             $table->foreignId('parent_element_id')
                 ->nullable()
                 ->constrained('elements')
                 ->restrictOnDelete();
             $table->unsignedInteger('position');
             $table->index([
-                'set_id',
+                'set_level_id',
                 'parent_element_id',
                 'position',
             ]);

From a64df64b76d2f511f99c1e16584fc04ca112c937 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 22:54:55 +0300
Subject: [PATCH 14/25] test level based scheduling

---
 backend/tests/Fakes/FakeElementRepository.php |  31 ++-
 .../tests/Fakes/FakeSetLevelRepository.php    |  76 +++++++
 .../Feature/Database/DatabaseSeederTest.php   |  14 ++
 .../Feature/Schedule/ScheduleEndpointTest.php |  77 ++++---
 .../Feature/Set/GetSetLayoutEndpointTest.php  |  57 ++++-
 .../Schedule/UseCases/CreateScheduleTest.php  | 201 ++++++++++++++----
 .../Unit/Set/UseCases/GetSetLayoutTest.php    |  53 +++--
 7 files changed, 415 insertions(+), 94 deletions(-)
 create mode 100644 backend/tests/Fakes/FakeSetLevelRepository.php

diff --git a/backend/tests/Fakes/FakeElementRepository.php b/backend/tests/Fakes/FakeElementRepository.php
index 1e9200d..628a37f 100644
--- a/backend/tests/Fakes/FakeElementRepository.php
+++ b/backend/tests/Fakes/FakeElementRepository.php
@@ -22,8 +22,7 @@ class FakeElementRepository implements ElementRepository
         $element = new Element(
             id: $id,
             name: $dto->name,
-            kind: $dto->kind,
-            set: $dto->set,
+            level: $dto->level,
             parentElement: $dto->parentElement,
             position: $this->nextPosition($dto),
         );
@@ -88,14 +87,32 @@ class FakeElementRepository implements ElementRepository
     {
         $parentElement = $dto->parentElement;
         if ($parentElement === null) {
+            if ($dto->level->getDepth() !== 0) {
+                throw new DomainException(
+                    'root element must use the first set level',
+                );
+            }
+
             return;
         }
 
-        if ($parentElement->getSet()->getId() !== $dto->set->getId()) {
+        if (
+            $parentElement->getSet()->getId()
+            !== $dto->level->getSet()->getId()
+        ) {
             throw new DomainException(
                 'parent element must belong to the same set',
             );
         }
+
+        if (
+            $dto->level->getDepth()
+            !== $parentElement->getLevel()->getDepth() + 1
+        ) {
+            throw new DomainException(
+                'child element must use the next set level',
+            );
+        }
     }
 
     private function nextPosition(CreateElementDto $dto): int
@@ -104,7 +121,10 @@ class FakeElementRepository implements ElementRepository
         $maximumPosition = 0;
 
         foreach ($this->elements as $element) {
-            if ($element->getSet()->getId() !== $dto->set->getId()) {
+            if (
+                $element->getSet()->getId()
+                !== $dto->level->getSet()->getId()
+            ) {
                 continue;
             }
 
@@ -150,8 +170,7 @@ class FakeElementRepository implements ElementRepository
         return new Element(
             id: $element->getId(),
             name: $element->getName(),
-            kind: $element->getKind(),
-            set: $element->getSet(),
+            level: $element->getLevel(),
             parentElement: $parentElement === null
                 ? null
                 : $this->copy($parentElement),
diff --git a/backend/tests/Fakes/FakeSetLevelRepository.php b/backend/tests/Fakes/FakeSetLevelRepository.php
new file mode 100644
index 0000000..0f3f076
--- /dev/null
+++ b/backend/tests/Fakes/FakeSetLevelRepository.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Tests\Fakes;
+
+use App\Set\CreateSetLevelDto;
+use App\Set\Set;
+use App\Set\SetLevel;
+use App\Set\SetLevelRepository;
+use DomainException;
+
+class FakeSetLevelRepository implements SetLevelRepository
+{
+    /**
+     * @var array<int, SetLevel>
+     */
+    private array $levels = [];
+
+    public function create(CreateSetLevelDto $dto): SetLevel
+    {
+        foreach ($this->levels as $level) {
+            if (
+                $level->getSet()->getId() === $dto->set->getId()
+                && $level->getKind() === $dto->kind
+            ) {
+                throw new DomainException(
+                    'level kind must be unique within set',
+                );
+            }
+        }
+
+        $id = count($this->levels) + 1;
+        $level = new SetLevel(
+            id: $id,
+            set: $dto->set,
+            kind: $dto->kind,
+            depth: count($this->findBySet($dto->set)),
+        );
+        $this->levels[$id] = $level;
+
+        return $this->copy($level);
+    }
+
+    public function find(int $id): ?SetLevel
+    {
+        $level = $this->levels[$id] ?? null;
+
+        return $level === null ? null : $this->copy($level);
+    }
+
+    public function findBySet(Set $set): array
+    {
+        $levels = array_filter(
+            $this->levels,
+            function (SetLevel $level) use ($set): bool {
+                return $level->getSet()->getId() === $set->getId();
+            },
+        );
+        usort($levels, function (SetLevel $first, SetLevel $second): int {
+            return $first->getDepth() <=> $second->getDepth();
+        });
+
+        return array_map(function (SetLevel $level): SetLevel {
+            return $this->copy($level);
+        }, $levels);
+    }
+
+    private function copy(SetLevel $level): SetLevel
+    {
+        return new SetLevel(
+            id: $level->getId(),
+            set: $level->getSet(),
+            kind: $level->getKind(),
+            depth: $level->getDepth(),
+        );
+    }
+}
diff --git a/backend/tests/Feature/Database/DatabaseSeederTest.php b/backend/tests/Feature/Database/DatabaseSeederTest.php
index e6ce46e..59d8be8 100644
--- a/backend/tests/Feature/Database/DatabaseSeederTest.php
+++ b/backend/tests/Feature/Database/DatabaseSeederTest.php
@@ -6,6 +6,7 @@ use App\Auth\PasswordHasher;
 use App\Element\Element;
 use App\Element\ElementRepository;
 use App\Set\SetRepository;
+use App\Set\SetLevelRepository;
 use App\Shared\ValueObject\EmailAddress;
 use App\User\UserRepository;
 use Database\Seeders\UserSeeder;
@@ -70,6 +71,12 @@ class DatabaseSeederTest extends TestCase
 
         $sets = app(SetRepository::class)->all();
         $elementRepository = app(ElementRepository::class);
+        $setLevelRepository = app(SetLevelRepository::class);
+        $expectedLevels = [
+            'Bible' => ['book', 'portion', 'chapter'],
+            'Course' => ['module', 'lesson'],
+            'Fitness Program' => ['phase', 'workout', 'exercise'],
+        ];
         $expectedElements = [
             'Bible' => [
                 'Chapter 1:chapter:Creation',
@@ -100,9 +107,16 @@ class DatabaseSeederTest extends TestCase
             ],
         ];
 
+        $this->assertDatabaseCount('set_levels', 8);
         $this->assertDatabaseCount('elements', 21);
 
         foreach ($sets as $set) {
+            $this->assertSame(
+                $expectedLevels[$set->getName()],
+                array_map(function ($level): string {
+                    return $level->getKind();
+                }, $setLevelRepository->findBySet($set)),
+            );
             $signatures = array_map(function (Element $element): string {
                 $parentName = $element->getParentElement()?->getName()
                     ?? 'root';
diff --git a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
index 1093de8..e3aca06 100644
--- a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
+++ b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
@@ -9,7 +9,11 @@ use App\Element\ElementModel;
 use App\Element\ElementRepository;
 use App\Http\Middleware\AuthMiddleware;
 use App\Set\CreateSetDto;
+use App\Set\CreateSetLevelDto;
 use App\Set\Set;
+use App\Set\SetLevel;
+use App\Set\SetLevelModel;
+use App\Set\SetLevelRepository;
 use App\Set\SetModel;
 use App\Set\SetRepository;
 use App\Shared\ValueObject\EmailAddress;
@@ -32,42 +36,45 @@ class ScheduleEndpointTest extends TestCase
         $user = $this->createUser('reader@example.com');
         $creator = $this->createUser('creator@example.com');
         $set = $this->createSet($creator, 'Bible');
+        $bookLevel = $this->createLevel($set, 'book');
+        $portionLevel = $this->createLevel($set, 'portion');
+        $chapterLevel = $this->createLevel($set, 'chapter');
         $repository = app(ElementRepository::class);
         $genesis = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Genesis',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $creation = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Creation',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesis,
         ));
-        $chapterOne = $repository->create(new CreateElementDto(
-            set: $set,
+        $repository->create(new CreateElementDto(
             name: 'Chapter 1',
-            kind: 'chapter',
+            level: $chapterLevel,
             parentElement: $creation,
         ));
         $exodus = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Exodus',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
-        $chapterTwo = $repository->create(new CreateElementDto(
-            set: $set,
-            name: 'Chapter 1',
-            kind: 'chapter',
+        $shemot = $repository->create(new CreateElementDto(
+            name: 'Shemot',
+            level: $portionLevel,
             parentElement: $exodus,
         ));
+        $repository->create(new CreateElementDto(
+            name: 'Chapter 1',
+            level: $chapterLevel,
+            parentElement: $shemot,
+        ));
         $this->createSession($user, 'valid-token');
 
         $response = $this->credentialedPost('/api/schedules', [
             'setId' => $set->getId(),
-            'elementKind' => 'chapter',
+            'levelId' => $chapterLevel->getId(),
             'startDate' => '2026-08-10',
             'targetDate' => '2026-08-12',
         ]);
@@ -114,6 +121,7 @@ class ScheduleEndpointTest extends TestCase
                                     'kind' => 'chapter',
                                     'path' => [
                                         'Exodus',
+                                        'Shemot',
                                         'Chapter 1',
                                     ],
                                 ],
@@ -144,6 +152,7 @@ class ScheduleEndpointTest extends TestCase
         ]);
         $this->assertDatabaseCount('schedule_assignments', 2);
         $this->assertFalse(Schema::hasColumn('schedules', 'set_id'));
+        $this->assertFalse(Schema::hasColumn('schedules', 'set_level_id'));
         $this->assertFalse(Schema::hasColumn(
             'schedule_assignments',
             'element_id',
@@ -159,10 +168,10 @@ class ScheduleEndpointTest extends TestCase
         $user = $this->createUser('reader@example.com');
         $otherUser = $this->createUser('other@example.com');
         $set = $this->createSet($user, 'Course');
+        $lessonLevel = $this->createLevel($set, 'lesson');
         app(ElementRepository::class)->create(new CreateElementDto(
-            set: $set,
             name: 'Welcome',
-            kind: 'lesson',
+            level: $lessonLevel,
             parentElement: null,
         ));
         $this->createSession($user, 'valid-token');
@@ -170,13 +179,13 @@ class ScheduleEndpointTest extends TestCase
 
         $this->credentialedPost('/api/schedules', [
             'setId' => $set->getId(),
-            'elementKind' => 'lesson',
+            'levelId' => $lessonLevel->getId(),
             'startDate' => '2026-08-01',
             'targetDate' => '2026-08-01',
         ])->assertCreated();
         $this->credentialedPost('/api/schedules', [
             'setId' => $set->getId(),
-            'elementKind' => 'lesson',
+            'levelId' => $lessonLevel->getId(),
             'startDate' => '2026-09-01',
             'targetDate' => '2026-09-01',
         ])->assertCreated();
@@ -186,7 +195,7 @@ class ScheduleEndpointTest extends TestCase
                 'other-token',
             )->postJson('/api/schedules', [
                 'setId' => $set->getId(),
-                'elementKind' => 'lesson',
+                'levelId' => $lessonLevel->getId(),
                 'startDate' => '2026-10-01',
                 'targetDate' => '2026-10-01',
             ])->assertCreated();
@@ -223,23 +232,23 @@ class ScheduleEndpointTest extends TestCase
     {
         $user = $this->createUser('reader@example.com');
         $set = $this->createSet($user, 'Original set');
+        $groupLevel = $this->createLevel($set, 'group');
+        $taskLevel = $this->createLevel($set, 'task');
         $repository = app(ElementRepository::class);
         $parent = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Original parent',
-            kind: 'group',
+            level: $groupLevel,
             parentElement: null,
         ));
         $element = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Original item',
-            kind: 'task',
+            level: $taskLevel,
             parentElement: $parent,
         ));
         $this->createSession($user, 'valid-token');
         $createdResponse = $this->credentialedPost('/api/schedules', [
             'setId' => $set->getId(),
-            'elementKind' => 'task',
+            'levelId' => $taskLevel->getId(),
             'startDate' => '2026-08-10',
             'targetDate' => '2026-08-10',
         ])->assertCreated();
@@ -247,12 +256,14 @@ class ScheduleEndpointTest extends TestCase
         SetModel::query()->whereKey($set->getId())->update([
             'name' => 'Changed set',
         ]);
+        SetLevelModel::query()->whereKey($taskLevel->getId())->update([
+            'kind' => 'changed-kind',
+        ]);
         ElementModel::query()->whereKey($parent->getId())->update([
             'name' => 'Changed parent',
         ]);
         ElementModel::query()->whereKey($element->getId())->update([
             'name' => 'Changed item',
-            'kind' => 'changed-kind',
         ]);
 
         $this->credentialedGet('/api/schedules/1')
@@ -273,10 +284,10 @@ class ScheduleEndpointTest extends TestCase
         $owner = $this->createUser('owner@example.com');
         $viewer = $this->createUser('viewer@example.com');
         $set = $this->createSet($owner, 'Course');
+        $lessonLevel = $this->createLevel($set, 'lesson');
         app(ElementRepository::class)->create(new CreateElementDto(
-            set: $set,
             name: 'Welcome',
-            kind: 'lesson',
+            level: $lessonLevel,
             parentElement: null,
         ));
         $this->createSession($owner, 'owner-token');
@@ -288,7 +299,7 @@ class ScheduleEndpointTest extends TestCase
                 'owner-token',
             )->postJson('/api/schedules', [
                 'setId' => $set->getId(),
-                'elementKind' => 'lesson',
+                'levelId' => $lessonLevel->getId(),
                 'startDate' => '2026-08-01',
                 'targetDate' => '2026-08-01',
             ])->assertCreated();
@@ -309,7 +320,7 @@ class ScheduleEndpointTest extends TestCase
 
         $this->credentialedPost('/api/schedules', [
             'setId' => 999,
-            'elementKind' => 'chapter',
+            'levelId' => 1,
             'startDate' => '2026-08-12',
             'targetDate' => '2026-08-10',
         ])->assertNotFound()->assertExactJson([
@@ -340,6 +351,14 @@ class ScheduleEndpointTest extends TestCase
         ));
     }
 
+    private function createLevel(Set $set, string $kind): SetLevel
+    {
+        return app(SetLevelRepository::class)->create(new CreateSetLevelDto(
+            set: $set,
+            kind: $kind,
+        ));
+    }
+
     private function createSession(User $user, string $token): void
     {
         $createdAt = new DateTimeImmutable(
diff --git a/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php b/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php
index 3a71638..de3f898 100644
--- a/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php
+++ b/backend/tests/Feature/Set/GetSetLayoutEndpointTest.php
@@ -8,7 +8,10 @@ use App\Element\CreateElementDto;
 use App\Element\ElementRepository;
 use App\Http\Middleware\AuthMiddleware;
 use App\Set\CreateSetDto;
+use App\Set\CreateSetLevelDto;
 use App\Set\Set;
+use App\Set\SetLevel;
+use App\Set\SetLevelRepository;
 use App\Set\SetRepository;
 use App\Shared\ValueObject\EmailAddress;
 use App\User\CreateUserDto;
@@ -29,28 +32,27 @@ class GetSetLayoutEndpointTest extends TestCase
         $user = $this->createUser();
         $set = $this->createSet($user, 'Bible');
         $repository = app(ElementRepository::class);
+        $bookLevel = $this->createLevel($set, 'book');
+        $portionLevel = $this->createLevel($set, 'portion');
+        $chapterLevel = $this->createLevel($set, 'chapter');
         $genesis = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Genesis',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Exodus',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $creation = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Creation',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesis,
         ));
         $chapter = $repository->create(new CreateElementDto(
-            set: $set,
             name: 'Chapter 1',
-            kind: 'chapter',
+            level: $chapterLevel,
             parentElement: $creation,
         ));
         $this->createSession($user);
@@ -62,21 +64,44 @@ class GetSetLayoutEndpointTest extends TestCase
                 'id' => $set->getId(),
                 'name' => 'Bible',
             ],
+            'levels' => [
+                [
+                    'id' => $bookLevel->getId(),
+                    'kind' => 'book',
+                    'depth' => 0,
+                    'elementCount' => 2,
+                ],
+                [
+                    'id' => $portionLevel->getId(),
+                    'kind' => 'portion',
+                    'depth' => 1,
+                    'elementCount' => 1,
+                ],
+                [
+                    'id' => $chapterLevel->getId(),
+                    'kind' => 'chapter',
+                    'depth' => 2,
+                    'elementCount' => 1,
+                ],
+            ],
             'elements' => [
                 [
                     'id' => $genesis->getId(),
                     'name' => 'Genesis',
                     'kind' => 'book',
+                    'levelId' => $bookLevel->getId(),
                     'children' => [
                         [
                             'id' => $creation->getId(),
                             'name' => 'Creation',
                             'kind' => 'portion',
+                            'levelId' => $portionLevel->getId(),
                             'children' => [
                                 [
                                     'id' => $chapter->getId(),
                                     'name' => 'Chapter 1',
                                     'kind' => 'chapter',
+                                    'levelId' => $chapterLevel->getId(),
                                     'children' => [],
                                 ],
                             ],
@@ -87,6 +112,7 @@ class GetSetLayoutEndpointTest extends TestCase
                     'id' => $genesis->getId() + 1,
                     'name' => 'Exodus',
                     'kind' => 'book',
+                    'levelId' => $bookLevel->getId(),
                     'children' => [],
                 ],
             ],
@@ -97,6 +123,7 @@ class GetSetLayoutEndpointTest extends TestCase
     {
         $user = $this->createUser();
         $set = $this->createSet($user, 'Empty set');
+        $taskLevel = $this->createLevel($set, 'task');
         $this->createSession($user);
 
         $response = $this->credentialedGet("/api/sets/{$set->getId()}");
@@ -106,6 +133,12 @@ class GetSetLayoutEndpointTest extends TestCase
                 'id' => $set->getId(),
                 'name' => 'Empty set',
             ],
+            'levels' => [[
+                'id' => $taskLevel->getId(),
+                'kind' => 'task',
+                'depth' => 0,
+                'elementCount' => 0,
+            ]],
             'elements' => [],
         ]);
     }
@@ -147,6 +180,14 @@ class GetSetLayoutEndpointTest extends TestCase
         ));
     }
 
+    private function createLevel(Set $set, string $kind): SetLevel
+    {
+        return app(SetLevelRepository::class)->create(new CreateSetLevelDto(
+            set: $set,
+            kind: $kind,
+        ));
+    }
+
     private function createSession(User $user): void
     {
         $createdAt = new DateTimeImmutable(
diff --git a/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php b/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
index 3a4e715..02b7a83 100644
--- a/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
+++ b/backend/tests/Unit/Schedule/UseCases/CreateScheduleTest.php
@@ -8,92 +8,110 @@ use App\Exceptions\NotFoundException;
 use App\Schedule\UseCases\CreateSchedule\CreateSchedule;
 use App\Schedule\UseCases\CreateSchedule\CreateScheduleRequest;
 use App\Set\CreateSetDto;
+use App\Set\CreateSetLevelDto;
+use App\Set\Set;
+use App\Set\SetLevel;
 use App\Shared\ValueObject\EmailAddress;
 use App\User\User;
 use PHPUnit\Framework\TestCase;
 use Tests\Fakes\FakeElementRepository;
 use Tests\Fakes\FakeScheduleRepository;
 use Tests\Fakes\FakeSetRepository;
+use Tests\Fakes\FakeSetLevelRepository;
 
 class CreateScheduleTest extends TestCase
 {
-    public function test_it_schedules_every_matching_element_in_tree_order(): void
+    public function test_it_schedules_every_element_on_the_selected_level(): void
     {
         $user = $this->user();
         $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
         $elementRepository = new FakeElementRepository;
         $scheduleRepository = new FakeScheduleRepository;
         $set = $setRepository->create(new CreateSetDto(
             name: 'Bible',
             creator: $user,
         ));
+        $bookLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'book',
+        );
+        $portionLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'portion',
+        );
+        $chapterLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'chapter',
+        );
         $genesis = $elementRepository->create(new CreateElementDto(
-            set: $set,
             name: 'Genesis',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $exodus = $elementRepository->create(new CreateElementDto(
-            set: $set,
             name: 'Exodus',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
-        $exodusChapterOne = $elementRepository->create(
-            new CreateElementDto(
-                set: $set,
-                name: 'Exodus 1',
-                kind: 'chapter',
-                parentElement: $exodus,
-            ),
-        );
         $creation = $elementRepository->create(new CreateElementDto(
-            set: $set,
             name: 'Creation',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesis,
         ));
+        $shemot = $elementRepository->create(new CreateElementDto(
+            name: 'Shemot',
+            level: $portionLevel,
+            parentElement: $exodus,
+        ));
         $genesisChapterOne = $elementRepository->create(
             new CreateElementDto(
-                set: $set,
                 name: 'Genesis 1',
-                kind: 'chapter',
+                level: $chapterLevel,
                 parentElement: $creation,
             ),
         );
         $genesisChapterTwo = $elementRepository->create(
             new CreateElementDto(
-                set: $set,
                 name: 'Genesis 2',
-                kind: 'chapter',
+                level: $chapterLevel,
                 parentElement: $creation,
             ),
         );
         $genesisChapterThree = $elementRepository->create(
             new CreateElementDto(
-                set: $set,
                 name: 'Genesis 3',
-                kind: 'chapter',
+                level: $chapterLevel,
                 parentElement: $creation,
             ),
         );
+        $exodusChapterOne = $elementRepository->create(
+            new CreateElementDto(
+                name: 'Exodus 1',
+                level: $chapterLevel,
+                parentElement: $shemot,
+            ),
+        );
         $exodusChapterTwo = $elementRepository->create(
             new CreateElementDto(
-                set: $set,
                 name: 'Exodus 2',
-                kind: 'chapter',
-                parentElement: $exodus,
+                level: $chapterLevel,
+                parentElement: $shemot,
             ),
         );
 
         $schedule = (new CreateSchedule(
             $setRepository,
+            $setLevelRepository,
             $elementRepository,
             $scheduleRepository,
         ))->execute(new CreateScheduleRequest(
             user: $user,
             setId: $set->getId(),
-            elementKind: 'chapter',
+            levelId: $chapterLevel->getId(),
             startDate: '2026-08-10',
             targetDate: '2026-08-12',
         ));
@@ -139,29 +157,35 @@ class CreateScheduleTest extends TestCase
     {
         $user = $this->user();
         $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
         $elementRepository = new FakeElementRepository;
         $set = $setRepository->create(new CreateSetDto(
             name: 'Course',
             creator: $user,
         ));
+        $lessonLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'lesson',
+        );
 
         foreach (['First', 'Second', 'Third'] as $name) {
             $elementRepository->create(new CreateElementDto(
-                set: $set,
                 name: $name,
-                kind: 'lesson',
+                level: $lessonLevel,
                 parentElement: null,
             ));
         }
 
         $schedule = (new CreateSchedule(
             $setRepository,
+            $setLevelRepository,
             $elementRepository,
             new FakeScheduleRepository,
         ))->execute(new CreateScheduleRequest(
             user: $user,
             setId: $set->getId(),
-            elementKind: 'lesson',
+            levelId: $lessonLevel->getId(),
             startDate: '2026-08-10',
             targetDate: '2026-08-16',
         ));
@@ -178,26 +202,32 @@ class CreateScheduleTest extends TestCase
     {
         $user = $this->user();
         $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
         $elementRepository = new FakeElementRepository;
         $set = $setRepository->create(new CreateSetDto(
             name: 'Project',
             creator: $user,
         ));
+        $milestoneLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'milestone',
+        );
         $elementRepository->create(new CreateElementDto(
-            set: $set,
             name: 'Ship it',
-            kind: 'milestone',
+            level: $milestoneLevel,
             parentElement: null,
         ));
 
         $schedule = (new CreateSchedule(
             $setRepository,
+            $setLevelRepository,
             $elementRepository,
             new FakeScheduleRepository,
         ))->execute(new CreateScheduleRequest(
             user: $user,
             setId: $set->getId(),
-            elementKind: 'milestone',
+            levelId: $milestoneLevel->getId(),
             startDate: '2020-01-01',
             targetDate: '2030-01-01',
         ));
@@ -217,18 +247,19 @@ class CreateScheduleTest extends TestCase
 
         (new CreateSchedule(
             new FakeSetRepository,
+            new FakeSetLevelRepository,
             new FakeElementRepository,
             new FakeScheduleRepository,
         ))->execute(new CreateScheduleRequest(
             user: $this->user(),
             setId: 999,
-            elementKind: 'chapter',
+            levelId: 1,
             startDate: '2026-08-10',
             targetDate: '2026-08-12',
         ));
     }
 
-    public function test_it_rejects_an_unavailable_element_kind(): void
+    public function test_it_rejects_a_missing_level(): void
     {
         $user = $this->user();
         $setRepository = new FakeSetRepository;
@@ -238,18 +269,85 @@ class CreateScheduleTest extends TestCase
         ));
 
         $this->expectException(BadRequestException::class);
-        $this->expectExceptionMessage(
-            'elementKind is not available for set',
-        );
+        $this->expectExceptionMessage('levelId is required');
 
         (new CreateSchedule(
             $setRepository,
+            new FakeSetLevelRepository,
             new FakeElementRepository,
             new FakeScheduleRepository,
         ))->execute(new CreateScheduleRequest(
             user: $user,
             setId: $set->getId(),
-            elementKind: 'Chapter',
+            levelId: null,
+            startDate: '2026-08-10',
+            targetDate: '2026-08-12',
+        ));
+    }
+
+    public function test_it_rejects_a_level_from_another_set(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
+        $bible = $setRepository->create(new CreateSetDto(
+            name: 'Bible',
+            creator: $user,
+        ));
+        $course = $setRepository->create(new CreateSetDto(
+            name: 'Course',
+            creator: $user,
+        ));
+        $moduleLevel = $this->createLevel(
+            $setLevelRepository,
+            $course,
+            'module',
+        );
+
+        $this->expectException(BadRequestException::class);
+        $this->expectExceptionMessage('level is not available for set');
+
+        (new CreateSchedule(
+            $setRepository,
+            $setLevelRepository,
+            new FakeElementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $bible->getId(),
+            levelId: $moduleLevel->getId(),
+            startDate: '2026-08-10',
+            targetDate: '2026-08-12',
+        ));
+    }
+
+    public function test_it_rejects_a_level_without_elements(): void
+    {
+        $user = $this->user();
+        $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
+        $set = $setRepository->create(new CreateSetDto(
+            name: 'Bible',
+            creator: $user,
+        ));
+        $chapterLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'chapter',
+        );
+
+        $this->expectException(BadRequestException::class);
+        $this->expectExceptionMessage('level has no elements');
+
+        (new CreateSchedule(
+            $setRepository,
+            $setLevelRepository,
+            new FakeElementRepository,
+            new FakeScheduleRepository,
+        ))->execute(new CreateScheduleRequest(
+            user: $user,
+            setId: $set->getId(),
+            levelId: $chapterLevel->getId(),
             startDate: '2026-08-10',
             targetDate: '2026-08-12',
         ));
@@ -259,22 +357,29 @@ class CreateScheduleTest extends TestCase
     {
         $user = $this->user();
         $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
         $set = $setRepository->create(new CreateSetDto(
             name: 'Bible',
             creator: $user,
         ));
+        $chapterLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'chapter',
+        );
 
         $this->expectException(BadRequestException::class);
         $this->expectExceptionMessage('startDate must be a valid date');
 
         (new CreateSchedule(
             $setRepository,
+            $setLevelRepository,
             new FakeElementRepository,
             new FakeScheduleRepository,
         ))->execute(new CreateScheduleRequest(
             user: $user,
             setId: $set->getId(),
-            elementKind: 'chapter',
+            levelId: $chapterLevel->getId(),
             startDate: '2026-02-30',
             targetDate: '2026-08-12',
         ));
@@ -284,10 +389,16 @@ class CreateScheduleTest extends TestCase
     {
         $user = $this->user();
         $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
         $set = $setRepository->create(new CreateSetDto(
             name: 'Bible',
             creator: $user,
         ));
+        $chapterLevel = $this->createLevel(
+            $setLevelRepository,
+            $set,
+            'chapter',
+        );
 
         $this->expectException(BadRequestException::class);
         $this->expectExceptionMessage(
@@ -296,17 +407,29 @@ class CreateScheduleTest extends TestCase
 
         (new CreateSchedule(
             $setRepository,
+            $setLevelRepository,
             new FakeElementRepository,
             new FakeScheduleRepository,
         ))->execute(new CreateScheduleRequest(
             user: $user,
             setId: $set->getId(),
-            elementKind: 'chapter',
+            levelId: $chapterLevel->getId(),
             startDate: '2026-08-12',
             targetDate: '2026-08-10',
         ));
     }
 
+    private function createLevel(
+        FakeSetLevelRepository $repository,
+        Set $set,
+        string $kind,
+    ): SetLevel {
+        return $repository->create(new CreateSetLevelDto(
+            set: $set,
+            kind: $kind,
+        ));
+    }
+
     private function user(): User
     {
         return new User(
diff --git a/backend/tests/Unit/Set/UseCases/GetSetLayoutTest.php b/backend/tests/Unit/Set/UseCases/GetSetLayoutTest.php
index 69a7714..2b4a7f1 100644
--- a/backend/tests/Unit/Set/UseCases/GetSetLayoutTest.php
+++ b/backend/tests/Unit/Set/UseCases/GetSetLayoutTest.php
@@ -5,6 +5,7 @@ namespace Tests\Unit\Set\UseCases;
 use App\Element\CreateElementDto;
 use App\Exceptions\NotFoundException;
 use App\Set\CreateSetDto;
+use App\Set\CreateSetLevelDto;
 use App\Set\UseCases\GetSetLayout\ElementLayoutNode;
 use App\Set\UseCases\GetSetLayout\GetSetLayout;
 use App\Set\UseCases\GetSetLayout\GetSetLayoutRequest;
@@ -13,6 +14,7 @@ use App\User\User;
 use PHPUnit\Framework\TestCase;
 use Tests\Fakes\FakeElementRepository;
 use Tests\Fakes\FakeSetRepository;
+use Tests\Fakes\FakeSetLevelRepository;
 
 class GetSetLayoutTest extends TestCase
 {
@@ -24,6 +26,7 @@ class GetSetLayoutTest extends TestCase
             passwordHash: 'hashed-password',
         );
         $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
         $elementRepository = new FakeElementRepository;
         $bible = $setRepository->create(new CreateSetDto(
             name: 'Bible',
@@ -33,51 +36,69 @@ class GetSetLayoutTest extends TestCase
             name: 'Course',
             creator: $creator,
         ));
-        $genesis = $elementRepository->create(new CreateElementDto(
+        $bookLevel = $setLevelRepository->create(new CreateSetLevelDto(
             set: $bible,
-            name: 'Genesis',
             kind: 'book',
+        ));
+        $portionLevel = $setLevelRepository->create(new CreateSetLevelDto(
+            set: $bible,
+            kind: 'portion',
+        ));
+        $chapterLevel = $setLevelRepository->create(new CreateSetLevelDto(
+            set: $bible,
+            kind: 'chapter',
+        ));
+        $moduleLevel = $setLevelRepository->create(new CreateSetLevelDto(
+            set: $course,
+            kind: 'module',
+        ));
+        $genesis = $elementRepository->create(new CreateElementDto(
+            name: 'Genesis',
+            level: $bookLevel,
             parentElement: null,
         ));
         $elementRepository->create(new CreateElementDto(
-            set: $bible,
             name: 'Exodus',
-            kind: 'book',
+            level: $bookLevel,
             parentElement: null,
         ));
         $creation = $elementRepository->create(new CreateElementDto(
-            set: $bible,
             name: 'Creation',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesis,
         ));
         $elementRepository->create(new CreateElementDto(
-            set: $bible,
             name: 'Noah',
-            kind: 'portion',
+            level: $portionLevel,
             parentElement: $genesis,
         ));
         $elementRepository->create(new CreateElementDto(
-            set: $bible,
             name: 'Chapter 1',
-            kind: 'chapter',
+            level: $chapterLevel,
             parentElement: $creation,
         ));
         $elementRepository->create(new CreateElementDto(
-            set: $course,
             name: 'Foundations',
-            kind: 'module',
+            level: $moduleLevel,
             parentElement: null,
         ));
 
         $layout = (new GetSetLayout(
             $setRepository,
+            $setLevelRepository,
             $elementRepository,
         ))->execute(new GetSetLayoutRequest(
             setId: $bible->getId(),
         ));
 
         $this->assertSame('Bible', $layout->getSet()->getName());
+        $this->assertSame(
+            ['book:2', 'portion:2', 'chapter:1'],
+            array_map(function ($level): string {
+                return $level->getLevel()->getKind()
+                    . ":{$level->getElementCount()}";
+            }, $layout->getLevels()),
+        );
         $this->assertSame(
             ['Genesis', 'Exodus'],
             $this->nodeNames($layout->getElements()),
@@ -103,19 +124,26 @@ class GetSetLayoutTest extends TestCase
             passwordHash: 'hashed-password',
         );
         $setRepository = new FakeSetRepository;
+        $setLevelRepository = new FakeSetLevelRepository;
         $set = $setRepository->create(new CreateSetDto(
             name: 'Empty set',
             creator: $creator,
         ));
+        $setLevelRepository->create(new CreateSetLevelDto(
+            set: $set,
+            kind: 'task',
+        ));
 
         $layout = (new GetSetLayout(
             $setRepository,
+            $setLevelRepository,
             new FakeElementRepository,
         ))->execute(new GetSetLayoutRequest(
             setId: $set->getId(),
         ));
 
         $this->assertSame([], $layout->getElements());
+        $this->assertSame(0, $layout->getLevels()[0]->getElementCount());
     }
 
     public function test_it_rejects_an_unknown_set(): void
@@ -125,6 +153,7 @@ class GetSetLayoutTest extends TestCase
 
         (new GetSetLayout(
             new FakeSetRepository,
+            new FakeSetLevelRepository,
             new FakeElementRepository,
         ))->execute(new GetSetLayoutRequest(
             setId: 999,

From 3cf1aff6a95fd133811cde2a42d389c10aa09667 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 22:57:15 +0300
Subject: [PATCH 15/25] schedule explicit set levels

---
 .../Http/Controllers/ScheduleController.php   |  2 +-
 .../app/Http/Controllers/SetController.php    | 16 ++++++
 .../CreateSchedule/CreateSchedule.php         | 26 +++++++---
 .../CreateSchedule/CreateScheduleRequest.php  |  2 +-
 .../UseCases/GetSetLayout/GetSetLayout.php    | 18 ++++++-
 .../Set/UseCases/GetSetLayout/SetLayout.php   | 10 ++++
 .../UseCases/GetSetLayout/SetLayoutLevel.php  | 23 +++++++++
 backend/database/seeders/DatabaseSeeder.php   |  1 +
 backend/database/seeders/ElementSeeder.php    | 51 +++++++++----------
 backend/database/seeders/SetLevelSeeder.php   | 45 ++++++++++++++++
 10 files changed, 156 insertions(+), 38 deletions(-)
 create mode 100644 backend/app/Set/UseCases/GetSetLayout/SetLayoutLevel.php
 create mode 100644 backend/database/seeders/SetLevelSeeder.php

diff --git a/backend/app/Http/Controllers/ScheduleController.php b/backend/app/Http/Controllers/ScheduleController.php
index fb0bb40..cc8cd60 100644
--- a/backend/app/Http/Controllers/ScheduleController.php
+++ b/backend/app/Http/Controllers/ScheduleController.php
@@ -34,7 +34,7 @@ class ScheduleController extends Controller
                 new CreateScheduleRequest(
                     user: $user,
                     setId: $input->integer('setId'),
-                    elementKind: $input->string('elementKind'),
+                    levelId: $input->integer('levelId'),
                     startDate: $input->string('startDate'),
                     targetDate: $input->string('targetDate'),
                 ),
diff --git a/backend/app/Http/Controllers/SetController.php b/backend/app/Http/Controllers/SetController.php
index 024e83c..fe09b72 100644
--- a/backend/app/Http/Controllers/SetController.php
+++ b/backend/app/Http/Controllers/SetController.php
@@ -7,6 +7,7 @@ use App\Set\Set;
 use App\Set\UseCases\GetSetLayout\ElementLayoutNode;
 use App\Set\UseCases\GetSetLayout\GetSetLayout;
 use App\Set\UseCases\GetSetLayout\GetSetLayoutRequest;
+use App\Set\UseCases\GetSetLayout\SetLayoutLevel;
 use App\Set\UseCases\ListSets\ListSets;
 use Illuminate\Http\JsonResponse;
 
@@ -49,6 +50,19 @@ class SetController extends Controller
                 'id' => $set->getId(),
                 'name' => $set->getName(),
             ],
+            'levels' => array_map(
+                function (SetLayoutLevel $layoutLevel): array {
+                    $level = $layoutLevel->getLevel();
+
+                    return [
+                        'id' => $level->getId(),
+                        'kind' => $level->getKind(),
+                        'depth' => $level->getDepth(),
+                        'elementCount' => $layoutLevel->getElementCount(),
+                    ];
+                },
+                $layout->getLevels(),
+            ),
             'elements' => array_map(
                 function (ElementLayoutNode $node): array {
                     return $this->elementPayload($node);
@@ -63,6 +77,7 @@ class SetController extends Controller
      *     id: int,
      *     name: string,
      *     kind: string,
+     *     levelId: int,
      *     children: list<mixed>
      * }
      */
@@ -74,6 +89,7 @@ class SetController extends Controller
             'id' => $element->getId(),
             'name' => $element->getName(),
             'kind' => $element->getKind(),
+            'levelId' => $element->getLevel()->getId(),
             'children' => array_map(
                 function (ElementLayoutNode $childNode): array {
                     return $this->elementPayload($childNode);
diff --git a/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php b/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
index 1759d73..fb8635e 100644
--- a/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
+++ b/backend/app/Schedule/UseCases/CreateSchedule/CreateSchedule.php
@@ -11,6 +11,7 @@ use App\Schedule\CreateScheduleDto;
 use App\Schedule\Schedule;
 use App\Schedule\ScheduleRepository;
 use App\Set\Set;
+use App\Set\SetLevelRepository;
 use App\Set\SetRepository;
 use DateTimeImmutable;
 use DateTimeZone;
@@ -19,6 +20,7 @@ class CreateSchedule
 {
     public function __construct(
         private SetRepository $setRepository,
+        private SetLevelRepository $setLevelRepository,
         private ElementRepository $elementRepository,
         private ScheduleRepository $scheduleRepository,
     ) {}
@@ -38,8 +40,18 @@ class CreateSchedule
             throw new NotFoundException('set not found');
         }
 
-        if ($request->elementKind === null || $request->elementKind === '') {
-            throw new BadRequestException('elementKind is required');
+        if ($request->levelId === null || $request->levelId < 1) {
+            throw new BadRequestException('levelId is required');
+        }
+
+        $level = $this->setLevelRepository->find($request->levelId);
+        if (
+            $level === null
+            || $level->getSet()->getId() !== $set->getId()
+        ) {
+            throw new BadRequestException(
+                'level is not available for set',
+            );
         }
 
         $startDate = $this->parseDate($request->startDate, 'startDate');
@@ -52,14 +64,12 @@ class CreateSchedule
 
         $elements = array_values(array_filter(
             $this->orderedElements($set),
-            function (Element $element) use ($request): bool {
-                return $element->getKind() === $request->elementKind;
+            function (Element $element) use ($level): bool {
+                return $element->getLevel()->getId() === $level->getId();
             },
         ));
         if ($elements === []) {
-            throw new BadRequestException(
-                'elementKind is not available for set',
-            );
+            throw new BadRequestException('level has no elements');
         }
 
         $assignments = $this->assignments(
@@ -71,7 +81,7 @@ class CreateSchedule
         return $this->scheduleRepository->create(new CreateScheduleDto(
             user: $request->user,
             setName: $set->getName(),
-            elementKind: $request->elementKind,
+            elementKind: $level->getKind(),
             startDate: $startDate,
             targetDate: $targetDate,
             assignments: $assignments,
diff --git a/backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php b/backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php
index d75ab71..70ab5db 100644
--- a/backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php
+++ b/backend/app/Schedule/UseCases/CreateSchedule/CreateScheduleRequest.php
@@ -9,7 +9,7 @@ final readonly class CreateScheduleRequest
     public function __construct(
         public User $user,
         public ?int $setId,
-        public ?string $elementKind,
+        public ?int $levelId,
         public ?string $startDate,
         public ?string $targetDate,
     ) {}
diff --git a/backend/app/Set/UseCases/GetSetLayout/GetSetLayout.php b/backend/app/Set/UseCases/GetSetLayout/GetSetLayout.php
index 39085e1..12c59d9 100644
--- a/backend/app/Set/UseCases/GetSetLayout/GetSetLayout.php
+++ b/backend/app/Set/UseCases/GetSetLayout/GetSetLayout.php
@@ -6,11 +6,13 @@ use App\Element\Element;
 use App\Element\ElementRepository;
 use App\Exceptions\NotFoundException;
 use App\Set\SetRepository;
+use App\Set\SetLevelRepository;
 
 class GetSetLayout
 {
     public function __construct(
         private SetRepository $setRepository,
+        private SetLevelRepository $setLevelRepository,
         private ElementRepository $elementRepository,
     ) {}
 
@@ -24,10 +26,15 @@ class GetSetLayout
             throw new NotFoundException('set not found');
         }
 
+        $elements = $this->elementRepository->findBySet($set);
         $elementsByParentId = [];
-        foreach ($this->elementRepository->findBySet($set) as $element) {
+        $elementCountsByLevelId = [];
+        foreach ($elements as $element) {
             $parentId = $element->getParentElement()?->getId() ?? 0;
             $elementsByParentId[$parentId][] = $element;
+            $levelId = $element->getLevel()->getId();
+            $elementCountsByLevelId[$levelId]
+                = ($elementCountsByLevelId[$levelId] ?? 0) + 1;
         }
 
         foreach ($elementsByParentId as &$siblings) {
@@ -46,8 +53,17 @@ class GetSetLayout
         }
         unset($siblings);
 
+        $layoutLevels = [];
+        foreach ($this->setLevelRepository->findBySet($set) as $level) {
+            $layoutLevels[] = new SetLayoutLevel(
+                level: $level,
+                elementCount: $elementCountsByLevelId[$level->getId()] ?? 0,
+            );
+        }
+
         return new SetLayout(
             set: $set,
+            levels: $layoutLevels,
             elements: $this->buildNodes(0, $elementsByParentId),
         );
     }
diff --git a/backend/app/Set/UseCases/GetSetLayout/SetLayout.php b/backend/app/Set/UseCases/GetSetLayout/SetLayout.php
index c98974a..69cf008 100644
--- a/backend/app/Set/UseCases/GetSetLayout/SetLayout.php
+++ b/backend/app/Set/UseCases/GetSetLayout/SetLayout.php
@@ -7,10 +7,12 @@ use App\Set\Set;
 final readonly class SetLayout
 {
     /**
+     * @param list<SetLayoutLevel> $levels
      * @param list<ElementLayoutNode> $elements
      */
     public function __construct(
         private Set $set,
+        private array $levels,
         private array $elements,
     ) {}
 
@@ -19,6 +21,14 @@ final readonly class SetLayout
         return $this->set;
     }
 
+    /**
+     * @return list<SetLayoutLevel>
+     */
+    public function getLevels(): array
+    {
+        return $this->levels;
+    }
+
     /**
      * @return list<ElementLayoutNode>
      */
diff --git a/backend/app/Set/UseCases/GetSetLayout/SetLayoutLevel.php b/backend/app/Set/UseCases/GetSetLayout/SetLayoutLevel.php
new file mode 100644
index 0000000..6ebac06
--- /dev/null
+++ b/backend/app/Set/UseCases/GetSetLayout/SetLayoutLevel.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Set\UseCases\GetSetLayout;
+
+use App\Set\SetLevel;
+
+final readonly class SetLayoutLevel
+{
+    public function __construct(
+        private SetLevel $level,
+        private int $elementCount,
+    ) {}
+
+    public function getLevel(): SetLevel
+    {
+        return $this->level;
+    }
+
+    public function getElementCount(): int
+    {
+        return $this->elementCount;
+    }
+}
diff --git a/backend/database/seeders/DatabaseSeeder.php b/backend/database/seeders/DatabaseSeeder.php
index c90217c..afd1905 100644
--- a/backend/database/seeders/DatabaseSeeder.php
+++ b/backend/database/seeders/DatabaseSeeder.php
@@ -13,6 +13,7 @@ class DatabaseSeeder extends Seeder
     {
         $this->call(UserSeeder::class);
         $this->call(SetSeeder::class);
+        $this->call(SetLevelSeeder::class);
         $this->call(ElementSeeder::class);
     }
 }
diff --git a/backend/database/seeders/ElementSeeder.php b/backend/database/seeders/ElementSeeder.php
index bde3ed9..52fe294 100644
--- a/backend/database/seeders/ElementSeeder.php
+++ b/backend/database/seeders/ElementSeeder.php
@@ -6,8 +6,11 @@ use App\Element\CreateElementDto;
 use App\Element\Element;
 use App\Element\ElementRepository;
 use App\Set\Set;
+use App\Set\SetLevel;
+use App\Set\SetLevelRepository;
 use App\Set\SetRepository;
 use Illuminate\Database\Seeder;
+use RuntimeException;
 
 class ElementSeeder extends Seeder
 {
@@ -15,38 +18,31 @@ class ElementSeeder extends Seeder
         'Bible' => [
             [
                 'name' => 'Genesis',
-                'kind' => 'book',
                 'children' => [
                     [
                         'name' => 'Creation',
-                        'kind' => 'portion',
                         'children' => [
                             [
                                 'name' => 'Chapter 1',
-                                'kind' => 'chapter',
                                 'children' => [],
                             ],
                             [
                                 'name' => 'Chapter 2',
-                                'kind' => 'chapter',
                                 'children' => [],
                             ],
                         ],
                     ],
                     [
                         'name' => 'Noah',
-                        'kind' => 'portion',
                         'children' => [],
                     ],
                 ],
             ],
             [
                 'name' => 'Exodus',
-                'kind' => 'book',
                 'children' => [
                     [
                         'name' => 'Shemot',
-                        'kind' => 'portion',
                         'children' => [],
                     ],
                 ],
@@ -55,32 +51,26 @@ class ElementSeeder extends Seeder
         'Course' => [
             [
                 'name' => 'Foundations',
-                'kind' => 'module',
                 'children' => [
                     [
                         'name' => 'Welcome',
-                        'kind' => 'lesson',
                         'children' => [],
                     ],
                     [
                         'name' => 'Core Concepts',
-                        'kind' => 'lesson',
                         'children' => [],
                     ],
                 ],
             ],
             [
                 'name' => 'Applied Practice',
-                'kind' => 'module',
                 'children' => [
                     [
                         'name' => 'Guided Exercise',
-                        'kind' => 'lesson',
                         'children' => [],
                     ],
                     [
                         'name' => 'Final Review',
-                        'kind' => 'lesson',
                         'children' => [],
                     ],
                 ],
@@ -89,31 +79,25 @@ class ElementSeeder extends Seeder
         'Fitness Program' => [
             [
                 'name' => 'Foundation Phase',
-                'kind' => 'phase',
                 'children' => [
                     [
                         'name' => 'Strength Day',
-                        'kind' => 'workout',
                         'children' => [
                             [
                                 'name' => 'Squat',
-                                'kind' => 'exercise',
                                 'children' => [],
                             ],
                             [
                                 'name' => 'Push-up',
-                                'kind' => 'exercise',
                                 'children' => [],
                             ],
                         ],
                     ],
                     [
                         'name' => 'Mobility Day',
-                        'kind' => 'workout',
                         'children' => [
                             [
                                 'name' => 'Hip Flow',
-                                'kind' => 'exercise',
                                 'children' => [],
                             ],
                         ],
@@ -122,11 +106,9 @@ class ElementSeeder extends Seeder
             ],
             [
                 'name' => 'Build Phase',
-                'kind' => 'phase',
                 'children' => [
                     [
                         'name' => 'Full Body Circuit',
-                        'kind' => 'workout',
                         'children' => [],
                     ],
                 ],
@@ -137,6 +119,7 @@ class ElementSeeder extends Seeder
     public function run(): void
     {
         $elementRepository = app(ElementRepository::class);
+        $setLevelRepository = app(SetLevelRepository::class);
 
         foreach (app(SetRepository::class)->all() as $set) {
             $definitions = self::ELEMENTS_BY_SET[$set->getName()] ?? null;
@@ -147,6 +130,8 @@ class ElementSeeder extends Seeder
             $this->seedChildren(
                 repository: $elementRepository,
                 set: $set,
+                levels: $setLevelRepository->findBySet($set),
+                depth: 0,
                 parentElement: null,
                 definitions: $definitions,
             );
@@ -156,16 +141,27 @@ class ElementSeeder extends Seeder
     /**
      * @param list<array{
      *     name: string,
-     *     kind: string,
      *     children: list<mixed>
      * }> $definitions
+     * @param list<SetLevel> $levels
      */
     private function seedChildren(
         ElementRepository $repository,
         Set $set,
+        array $levels,
+        int $depth,
         ?Element $parentElement,
         array $definitions,
     ): void {
+        if ($definitions === []) {
+            return;
+        }
+
+        $level = $levels[$depth] ?? null;
+        if ($level === null) {
+            throw new RuntimeException('element level not defined');
+        }
+
         $siblings = $parentElement === null
             ? $repository->findTopLevelBySet($set)
             : $repository->findByParentElement($parentElement);
@@ -174,13 +170,12 @@ class ElementSeeder extends Seeder
             $element = $this->findSibling(
                 siblings: $siblings,
                 name: $definition['name'],
-                kind: $definition['kind'],
+                level: $level,
             );
             if ($element === null) {
                 $element = $repository->create(new CreateElementDto(
-                    set: $set,
                     name: $definition['name'],
-                    kind: $definition['kind'],
+                    level: $level,
                     parentElement: $parentElement,
                 ));
                 $siblings[] = $element;
@@ -189,6 +184,8 @@ class ElementSeeder extends Seeder
             $this->seedChildren(
                 repository: $repository,
                 set: $set,
+                levels: $levels,
+                depth: $depth + 1,
                 parentElement: $element,
                 definitions: $definition['children'],
             );
@@ -201,12 +198,12 @@ class ElementSeeder extends Seeder
     private function findSibling(
         array $siblings,
         string $name,
-        string $kind,
+        SetLevel $level,
     ): ?Element {
         foreach ($siblings as $sibling) {
             if (
                 $sibling->getName() === $name
-                && $sibling->getKind() === $kind
+                && $sibling->getLevel()->getId() === $level->getId()
             ) {
                 return $sibling;
             }
diff --git a/backend/database/seeders/SetLevelSeeder.php b/backend/database/seeders/SetLevelSeeder.php
new file mode 100644
index 0000000..72c239c
--- /dev/null
+++ b/backend/database/seeders/SetLevelSeeder.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Database\Seeders;
+
+use App\Set\CreateSetLevelDto;
+use App\Set\SetLevelRepository;
+use App\Set\SetRepository;
+use Illuminate\Database\Seeder;
+
+class SetLevelSeeder extends Seeder
+{
+    private const array KINDS_BY_SET = [
+        'Bible' => ['book', 'portion', 'chapter'],
+        'Course' => ['module', 'lesson'],
+        'Fitness Program' => ['phase', 'workout', 'exercise'],
+    ];
+
+    public function run(): void
+    {
+        $repository = app(SetLevelRepository::class);
+
+        foreach (app(SetRepository::class)->all() as $set) {
+            $kinds = self::KINDS_BY_SET[$set->getName()] ?? null;
+            if ($kinds === null) {
+                continue;
+            }
+
+            $existingKinds = array_map(function ($level): string {
+                return $level->getKind();
+            }, $repository->findBySet($set));
+
+            foreach ($kinds as $kind) {
+                if (in_array($kind, $existingKinds, true)) {
+                    continue;
+                }
+
+                $repository->create(new CreateSetLevelDto(
+                    set: $set,
+                    kind: $kind,
+                ));
+                $existingKinds[] = $kind;
+            }
+        }
+    }
+}

From dfca13936a9e1c527efd52349305386021ef1b37 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 23:00:11 +0300
Subject: [PATCH 16/25] test explicit scheduling levels

---
 frontend/website/cypress/e2e/set-layout.cy.ts | 14 ++++++--
 .../website/cypress/e2e/set-scheduling.cy.ts  | 36 ++++++++++++++-----
 2 files changed, 38 insertions(+), 12 deletions(-)

diff --git a/frontend/website/cypress/e2e/set-layout.cy.ts b/frontend/website/cypress/e2e/set-layout.cy.ts
index 5430694..eab270a 100644
--- a/frontend/website/cypress/e2e/set-layout.cy.ts
+++ b/frontend/website/cypress/e2e/set-layout.cy.ts
@@ -5,29 +5,37 @@ const authenticatedUser = {
 
 const bibleLayout = {
   set: { id: 41, name: 'Bible' },
+  levels: [
+    { id: 1, kind: 'book', depth: 0, elementCount: 2 },
+    { id: 2, kind: 'portion', depth: 1, elementCount: 2 },
+    { id: 3, kind: 'chapter', depth: 2, elementCount: 1 },
+  ],
   elements: [
     {
       id: 1,
       name: 'Genesis',
       kind: 'book',
+      levelId: 1,
       children: [
         {
           id: 3,
           name: 'Creation',
           kind: 'portion',
+          levelId: 2,
           children: [
             {
               id: 4,
               name: 'Chapter 1',
               kind: 'chapter',
+              levelId: 3,
               children: [],
             },
           ],
         },
-        { id: 5, name: 'Noah', kind: 'portion', children: [] },
+        { id: 5, name: 'Noah', kind: 'portion', levelId: 2, children: [] },
       ],
     },
-    { id: 2, name: 'Exodus', kind: 'book', children: [] },
+    { id: 2, name: 'Exodus', kind: 'book', levelId: 1, children: [] },
   ],
 }
 
@@ -89,7 +97,7 @@ describe('set element layout', () => {
     cy.intercept('GET', '**/api/sets/41', {
       delay: 500,
       statusCode: 200,
-      body: { set: { id: 41, name: 'Empty set' }, elements: [] },
+      body: { set: { id: 41, name: 'Empty set' }, levels: [], elements: [] },
     }).as('layout')
 
     cy.visit('/sets/41')
diff --git a/frontend/website/cypress/e2e/set-scheduling.cy.ts b/frontend/website/cypress/e2e/set-scheduling.cy.ts
index 6ebe605..77a5d41 100644
--- a/frontend/website/cypress/e2e/set-scheduling.cy.ts
+++ b/frontend/website/cypress/e2e/set-scheduling.cy.ts
@@ -5,21 +5,29 @@ const authenticatedUser = {
 
 const bibleLayout = {
   set: { id: 41, name: 'Bible' },
+  levels: [
+    { id: 1, kind: 'book', depth: 0, elementCount: 2 },
+    { id: 2, kind: 'portion', depth: 1, elementCount: 2 },
+    { id: 3, kind: 'chapter', depth: 2, elementCount: 2 },
+  ],
   elements: [
     {
       id: 1,
       name: 'Genesis',
       kind: 'book',
+      levelId: 1,
       children: [
         {
           id: 3,
           name: 'Creation',
           kind: 'portion',
+          levelId: 2,
           children: [
             {
               id: 4,
               name: 'Chapter 1',
               kind: 'chapter',
+              levelId: 3,
               children: [],
             },
           ],
@@ -30,12 +38,22 @@ const bibleLayout = {
       id: 2,
       name: 'Exodus',
       kind: 'book',
+      levelId: 1,
       children: [
         {
           id: 5,
-          name: 'Chapter 1',
-          kind: 'chapter',
-          children: [],
+          name: 'Shemot',
+          kind: 'portion',
+          levelId: 2,
+          children: [
+            {
+              id: 6,
+              name: 'Chapter 1',
+              kind: 'chapter',
+              levelId: 3,
+              children: [],
+            },
+          ],
         },
       ],
     },
@@ -73,7 +91,7 @@ const scheduleDetail = {
             element: {
               name: 'Chapter 1',
               kind: 'chapter',
-              path: ['Exodus', 'Chapter 1'],
+              path: ['Exodus', 'Shemot', 'Chapter 1'],
             },
           },
         ],
@@ -103,7 +121,7 @@ describe('set scheduling', () => {
       expect(request.headers.accept).to.equal('application/json')
       expect(request.body).to.deep.equal({
         setId: 41,
-        elementKind: 'chapter',
+        levelId: 3,
         startDate: '2026-08-10',
         targetDate: '2026-08-12',
       })
@@ -121,10 +139,10 @@ describe('set scheduling', () => {
     cy.get('h1').should('have.text', 'Schedule Bible')
     cy.get('#schedule-level option').then(($options) => {
       expect([...$options].map((option) => option.textContent?.trim())).to.deep.equal(
-        ['Choose a level', 'Book (2)', 'Portion (1)', 'Chapter (2)'],
+        ['Choose a level', 'Book (2)', 'Portion (2)', 'Chapter (2)'],
       )
     })
-    cy.get('#schedule-level').select('chapter')
+    cy.get('#schedule-level').select('3')
     cy.get('#schedule-start-date').type('2026-08-10')
     cy.get('#schedule-target-date').type('2026-08-12')
     cy.get('form').submit()
@@ -141,7 +159,7 @@ describe('set scheduling', () => {
       .and('not.contain.text', 'Chapter 1')
     cy.get('[data-schedule-date="2026-08-12"]').should(
       'contain.text',
-      'Exodus / Chapter 1',
+      'Exodus / Shemot / Chapter 1',
     )
   })
 
@@ -168,7 +186,7 @@ describe('set scheduling', () => {
       .and('be.visible')
     cy.get('@createSchedule.all').should('have.length', 0)
 
-    cy.get('#schedule-level').select('chapter')
+    cy.get('#schedule-level').select('3')
     cy.get('#schedule-start-date').type('2026-08-12')
     cy.get('#schedule-target-date').type('2026-08-10')
     cy.get('form').submit()

From 8e38b8f7e87a4a4811de0603876e35ab86d1e6c9 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 23:02:18 +0300
Subject: [PATCH 17/25] use explicit scheduling levels

---
 frontend/website/src/stores/schedules.ts      |  2 +-
 frontend/website/src/stores/setLayout.ts      |  9 +++
 .../website/src/views/CreateScheduleView.vue  | 56 ++++++++-----------
 3 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/frontend/website/src/stores/schedules.ts b/frontend/website/src/stores/schedules.ts
index d5b46a2..f8844e6 100644
--- a/frontend/website/src/stores/schedules.ts
+++ b/frontend/website/src/stores/schedules.ts
@@ -51,7 +51,7 @@ export type ScheduleSummary = z.infer<typeof scheduleSummarySchema>
 export type ScheduleDetail = z.infer<typeof scheduleDetailSchema>
 export type CreateScheduleInput = {
   setId: number
-  elementKind: string
+  levelId: number
   startDate: string
   targetDate: string
 }
diff --git a/frontend/website/src/stores/setLayout.ts b/frontend/website/src/stores/setLayout.ts
index 919c108..2b097c4 100644
--- a/frontend/website/src/stores/setLayout.ts
+++ b/frontend/website/src/stores/setLayout.ts
@@ -8,6 +8,7 @@ export const setElementNodeSchema = z.object({
   id: z.number().int().positive(),
   name: z.string().min(1),
   kind: z.string().min(1),
+  levelId: z.number().int().positive(),
   get children() {
     return z.array(setElementNodeSchema)
   },
@@ -18,6 +19,14 @@ export const setLayoutResponseSchema = z.object({
     id: z.number().int().positive(),
     name: z.string().min(1),
   }),
+  levels: z.array(
+    z.object({
+      id: z.number().int().positive(),
+      kind: z.string().min(1),
+      depth: z.number().int().nonnegative(),
+      elementCount: z.number().int().nonnegative(),
+    }),
+  ),
   elements: z.array(setElementNodeSchema),
 })
 
diff --git a/frontend/website/src/views/CreateScheduleView.vue b/frontend/website/src/views/CreateScheduleView.vue
index 84cc585..87c5e39 100644
--- a/frontend/website/src/views/CreateScheduleView.vue
+++ b/frontend/website/src/views/CreateScheduleView.vue
@@ -6,9 +6,9 @@ import { z } from 'zod'
 
 import AuthenticatedHeader from '@/components/AuthenticatedHeader.vue'
 import { useSchedulesStore } from '@/stores/schedules'
-import { useSetLayoutStore, type SetElementNode } from '@/stores/setLayout'
+import { useSetLayoutStore } from '@/stores/setLayout'
 
-type ScheduleField = 'elementKind' | 'startDate' | 'targetDate'
+type ScheduleField = 'levelId' | 'startDate' | 'targetDate'
 type ScheduleFieldErrors = Partial<Record<ScheduleField, string>>
 
 const route = useRoute()
@@ -19,34 +19,24 @@ const { layout, loading, error, notFound } = storeToRefs(setLayoutStore)
 const { creating, createError } = storeToRefs(schedulesStore)
 const currentSetId = ref<number | null>(null)
 const form = reactive({
-  elementKind: '',
+  levelId: null as number | null,
   startDate: '',
   targetDate: '',
 })
 const fieldErrors = ref<ScheduleFieldErrors>({})
 
-const levels = computed(() => {
-  const counts = new Map<string, number>()
-
-  function countNodes(nodes: SetElementNode[]): void {
-    for (const node of nodes) {
-      counts.set(node.kind, (counts.get(node.kind) ?? 0) + 1)
-      countNodes(node.children)
-    }
-  }
-
-  countNodes(layout.value?.elements ?? [])
-
-  return [...counts.entries()].map(([kind, count]) => ({
-    kind,
-    count,
-    label: humanizeKind(kind),
-  }))
-})
+const levels = computed(() =>
+  (layout.value?.levels ?? [])
+    .filter((level) => level.elementCount > 0)
+    .map((level) => ({
+      ...level,
+      label: humanizeKind(level.kind),
+    })),
+)
 
 const scheduleFormSchema = z
   .object({
-    elementKind: z.string().min(1, 'Choose a level to schedule.'),
+    levelId: z.number('Choose a level to schedule.').int().positive(),
     startDate: z.string().min(1, 'Choose a start date.'),
     targetDate: z.string().min(1, 'Choose a target date.'),
   })
@@ -82,7 +72,7 @@ async function submit(): Promise<void> {
     for (const issue of result.error.issues) {
       const field = issue.path[0]
       if (
-        (field === 'elementKind' || field === 'startDate' || field === 'targetDate') &&
+        (field === 'levelId' || field === 'startDate' || field === 'targetDate') &&
         errors[field] === undefined
       ) {
         errors[field] = issue.message
@@ -95,10 +85,10 @@ async function submit(): Promise<void> {
 
   if (
     currentSetId.value === null ||
-    !levels.value.some((level) => level.kind === result.data.elementKind)
+    !levels.value.some((level) => level.id === result.data.levelId)
   ) {
     fieldErrors.value = {
-      elementKind: 'Choose an available level to schedule.',
+      levelId: 'Choose an available level to schedule.',
     }
 
     return
@@ -166,18 +156,18 @@ function humanizeKind(kind: string): string {
             <label for="schedule-level">Level</label>
             <select
               id="schedule-level"
-              v-model="form.elementKind"
-              :aria-invalid="fieldErrors.elementKind !== undefined"
-              :aria-describedby="fieldErrors.elementKind ? 'schedule-level-error' : undefined"
+              v-model="form.levelId"
+              :aria-invalid="fieldErrors.levelId !== undefined"
+              :aria-describedby="fieldErrors.levelId ? 'schedule-level-error' : undefined"
               :disabled="creating"
             >
-              <option value="">Choose a level</option>
-              <option v-for="level in levels" :key="level.kind" :value="level.kind">
-                {{ level.label }} ({{ level.count }})
+              <option :value="null">Choose a level</option>
+              <option v-for="level in levels" :key="level.id" :value="level.id">
+                {{ level.label }} ({{ level.elementCount }})
               </option>
             </select>
-            <p v-if="fieldErrors.elementKind" id="schedule-level-error" class="field-error">
-              {{ fieldErrors.elementKind }}
+            <p v-if="fieldErrors.levelId" id="schedule-level-error" class="field-error">
+              {{ fieldErrors.levelId }}
             </p>
           </div>
 

From 98a4e2e0079caa8707dd1770577ccff37684dad3 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Tue, 11 Aug 2026 23:02:45 +0300
Subject: [PATCH 18/25] document explicit set levels

---
 ai/shared.md | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/ai/shared.md b/ai/shared.md
index a6fe77d..ed0a14a 100644
--- a/ai/shared.md
+++ b/ai/shared.md
@@ -9,14 +9,17 @@ these rules.
 - Attainly is in early development.
 - Attainly helps users break hierarchical goals into scheduled assignments,
   complete daily work, and track progress toward a target date.
-- Schedules target whole sets. Users choose an element kind as the assignment
+- Sets define explicit ordered element levels. Every depth has one kind, and
+  a kind can appear at only one depth within a set. Root elements use the
+  first level, and children use the level immediately after their parent.
+- Schedules target whole sets. Users choose a set level as the assignment
   granularity. To schedule a subset, create a separate named set containing
   that subset.
 - Schedules are immutable historical snapshots. Copy the set name and each
   assignment's name, kind, and full path when creating a schedule.
-- Persisted schedules must not reference their source set, and persisted
-  assignments must not reference their source elements. Later source edits or
-  deletions must not change an existing schedule.
+- Persisted schedules must not reference their source set or selected level.
+  Persisted assignments must not reference their source elements. Later
+  source edits or deletions must not change an existing schedule.
 - Schedule recalculation must preserve completed work while redistributing
   unfinished assignments across the remaining dates.
 - Planned features in `README.md` are future ideas, not authorized scope.

From 00cfeebb9afd8b034a3d85a49be5f299ba29ab8c Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Fri, 14 Aug 2026 09:50:38 +0300
Subject: [PATCH 19/25] test verbatim kind labels

---
 .../website/cypress/e2e/set-scheduling.cy.ts  | 24 ++++++++++---------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/frontend/website/cypress/e2e/set-scheduling.cy.ts b/frontend/website/cypress/e2e/set-scheduling.cy.ts
index 77a5d41..1860145 100644
--- a/frontend/website/cypress/e2e/set-scheduling.cy.ts
+++ b/frontend/website/cypress/e2e/set-scheduling.cy.ts
@@ -8,7 +8,7 @@ const bibleLayout = {
   levels: [
     { id: 1, kind: 'book', depth: 0, elementCount: 2 },
     { id: 2, kind: 'portion', depth: 1, elementCount: 2 },
-    { id: 3, kind: 'chapter', depth: 2, elementCount: 2 },
+    { id: 3, kind: 'Chapter_sections-v2', depth: 2, elementCount: 2 },
   ],
   elements: [
     {
@@ -26,7 +26,7 @@ const bibleLayout = {
             {
               id: 4,
               name: 'Chapter 1',
-              kind: 'chapter',
+              kind: 'Chapter_sections-v2',
               levelId: 3,
               children: [],
             },
@@ -49,7 +49,7 @@ const bibleLayout = {
             {
               id: 6,
               name: 'Chapter 1',
-              kind: 'chapter',
+              kind: 'Chapter_sections-v2',
               levelId: 3,
               children: [],
             },
@@ -64,7 +64,7 @@ const scheduleDetail = {
   schedule: {
     id: 73,
     set: { name: 'Bible' },
-    elementKind: 'chapter',
+    elementKind: 'Chapter_sections-v2',
     startDate: '2026-08-10',
     targetDate: '2026-08-12',
     assignmentCount: 2,
@@ -76,7 +76,7 @@ const scheduleDetail = {
             id: 1,
             element: {
               name: 'Chapter 1',
-              kind: 'chapter',
+              kind: 'Chapter_sections-v2',
               path: ['Genesis', 'Creation', 'Chapter 1'],
             },
           },
@@ -90,7 +90,7 @@ const scheduleDetail = {
             id: 2,
             element: {
               name: 'Chapter 1',
-              kind: 'chapter',
+              kind: 'Chapter_sections-v2',
               path: ['Exodus', 'Shemot', 'Chapter 1'],
             },
           },
@@ -139,7 +139,7 @@ describe('set scheduling', () => {
     cy.get('h1').should('have.text', 'Schedule Bible')
     cy.get('#schedule-level option').then(($options) => {
       expect([...$options].map((option) => option.textContent?.trim())).to.deep.equal(
-        ['Choose a level', 'Book (2)', 'Portion (2)', 'Chapter (2)'],
+        ['Choose a level', 'Book (2)', 'Portion (2)', 'Chapter_sections-v2 (2)'],
       )
     })
     cy.get('#schedule-level').select('3')
@@ -153,7 +153,8 @@ describe('set scheduling', () => {
     cy.get('[data-schedule-day]').should('have.length', 3)
     cy.get('[data-schedule-date="2026-08-10"]')
       .should('contain.text', 'Genesis / Creation / Chapter 1')
-      .and('contain.text', 'Chapter')
+      .find('.assignment-kind')
+      .should('have.text', 'Chapter_sections-v2')
     cy.get('[data-schedule-date="2026-08-11"]')
       .should('contain.text', 'Rest day')
       .and('not.contain.text', 'Chapter 1')
@@ -207,7 +208,8 @@ describe('set scheduling', () => {
     cy.wait('@me')
     cy.wait('@schedule')
     cy.get('h1').should('have.text', 'Bible schedule')
-    cy.contains('2 chapters across 3 days').should('be.visible')
+    cy.get('.eyebrow').should('have.text', 'Chapter_sections-v2 plan')
+    cy.contains('2 Chapter_sections-v2 assignments across 3 days').should('be.visible')
 
     cy.intercept('GET', '**/api/schedules/74', {
       statusCode: 404,
@@ -232,7 +234,7 @@ describe('set scheduling', () => {
             {
               id: 73,
               set: { name: 'Bible' },
-              elementKind: 'chapter',
+              elementKind: 'Chapter_sections-v2',
               startDate: '2026-08-10',
               targetDate: '2026-08-12',
               assignmentCount: 2,
@@ -250,8 +252,8 @@ describe('set scheduling', () => {
     cy.get('#schedules-heading').should('have.text', 'Your schedules')
     cy.get('ul[aria-label="Your schedules"]')
       .should('contain.text', 'Bible')
-      .and('contain.text', 'Chapter')
       .and('contain.text', '2 assignments')
+    cy.get('.schedule-card__heading p').should('have.text', 'Chapter_sections-v2')
     cy.contains('a', 'Bible').should('have.attr', 'href', '/schedules/73')
   })
 })

From 2101ab50d23615fdfb312f64cceddf7569cb6fde Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Fri, 14 Aug 2026 09:52:46 +0300
Subject: [PATCH 20/25] test verbatim layout kinds

---
 frontend/website/cypress/e2e/set-layout.cy.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/frontend/website/cypress/e2e/set-layout.cy.ts b/frontend/website/cypress/e2e/set-layout.cy.ts
index eab270a..aad6b24 100644
--- a/frontend/website/cypress/e2e/set-layout.cy.ts
+++ b/frontend/website/cypress/e2e/set-layout.cy.ts
@@ -8,7 +8,7 @@ const bibleLayout = {
   levels: [
     { id: 1, kind: 'book', depth: 0, elementCount: 2 },
     { id: 2, kind: 'portion', depth: 1, elementCount: 2 },
-    { id: 3, kind: 'chapter', depth: 2, elementCount: 1 },
+    { id: 3, kind: 'Chapter_sections-v2', depth: 2, elementCount: 1 },
   ],
   elements: [
     {
@@ -26,7 +26,7 @@ const bibleLayout = {
             {
               id: 4,
               name: 'Chapter 1',
-              kind: 'chapter',
+              kind: 'Chapter_sections-v2',
               levelId: 3,
               children: [],
             },
@@ -90,7 +90,9 @@ describe('set element layout', () => {
       .and('have.attr', 'data-element-id', '4')
     cy.contains('.element-node__card', 'Chapter 1')
       .should('be.visible')
-      .and('contain.text', 'chapter')
+      .find('.element-node__kind')
+      .should('have.text', 'Chapter_sections-v2')
+      .and('have.css', 'text-transform', 'none')
   })
 
   it('shows loading and empty layout states', () => {

From 74feb38300692065351946d7ed0d4b61f0fbb7c2 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Fri, 14 Aug 2026 09:54:43 +0300
Subject: [PATCH 21/25] display user kinds verbatim

---
 .../website/cypress/e2e/set-scheduling.cy.ts  | 12 ++++--
 .../website/src/components/ElementTree.vue    |  2 +-
 .../website/src/views/CreateScheduleView.vue  | 15 +-------
 frontend/website/src/views/DashboardView.vue  | 12 +++---
 .../website/src/views/ScheduleDetailView.vue  | 37 ++++++-------------
 5 files changed, 28 insertions(+), 50 deletions(-)

diff --git a/frontend/website/cypress/e2e/set-scheduling.cy.ts b/frontend/website/cypress/e2e/set-scheduling.cy.ts
index 1860145..3c715a7 100644
--- a/frontend/website/cypress/e2e/set-scheduling.cy.ts
+++ b/frontend/website/cypress/e2e/set-scheduling.cy.ts
@@ -139,7 +139,7 @@ describe('set scheduling', () => {
     cy.get('h1').should('have.text', 'Schedule Bible')
     cy.get('#schedule-level option').then(($options) => {
       expect([...$options].map((option) => option.textContent?.trim())).to.deep.equal(
-        ['Choose a level', 'Book (2)', 'Portion (2)', 'Chapter_sections-v2 (2)'],
+        ['Choose a level', 'book (2)', 'portion (2)', 'Chapter_sections-v2 (2)'],
       )
     })
     cy.get('#schedule-level').select('3')
@@ -155,6 +155,7 @@ describe('set scheduling', () => {
       .should('contain.text', 'Genesis / Creation / Chapter 1')
       .find('.assignment-kind')
       .should('have.text', 'Chapter_sections-v2')
+      .and('have.css', 'text-transform', 'none')
     cy.get('[data-schedule-date="2026-08-11"]')
       .should('contain.text', 'Rest day')
       .and('not.contain.text', 'Chapter 1')
@@ -208,7 +209,10 @@ describe('set scheduling', () => {
     cy.wait('@me')
     cy.wait('@schedule')
     cy.get('h1').should('have.text', 'Bible schedule')
-    cy.get('.eyebrow').should('have.text', 'Chapter_sections-v2 plan')
+    cy.get('.eyebrow')
+      .should('have.text', 'Chapter_sections-v2 plan')
+      .find('.schedule-kind')
+      .should('have.css', 'text-transform', 'none')
     cy.contains('2 Chapter_sections-v2 assignments across 3 days').should('be.visible')
 
     cy.intercept('GET', '**/api/schedules/74', {
@@ -253,7 +257,9 @@ describe('set scheduling', () => {
     cy.get('ul[aria-label="Your schedules"]')
       .should('contain.text', 'Bible')
       .and('contain.text', '2 assignments')
-    cy.get('.schedule-card__heading p').should('have.text', 'Chapter_sections-v2')
+    cy.get('.schedule-card__heading p')
+      .should('have.text', 'Chapter_sections-v2')
+      .and('have.css', 'text-transform', 'none')
     cy.contains('a', 'Bible').should('have.attr', 'href', '/schedules/73')
   })
 })
diff --git a/frontend/website/src/components/ElementTree.vue b/frontend/website/src/components/ElementTree.vue
index 6cc1302..54d7e39 100644
--- a/frontend/website/src/components/ElementTree.vue
+++ b/frontend/website/src/components/ElementTree.vue
@@ -87,7 +87,7 @@ defineProps<{
   font-size: 0.62rem;
   font-weight: 800;
   letter-spacing: 0.1em;
-  text-transform: uppercase;
+  text-transform: none;
 }
 
 @media (max-width: 37.5rem) {
diff --git a/frontend/website/src/views/CreateScheduleView.vue b/frontend/website/src/views/CreateScheduleView.vue
index 87c5e39..deea7a2 100644
--- a/frontend/website/src/views/CreateScheduleView.vue
+++ b/frontend/website/src/views/CreateScheduleView.vue
@@ -26,12 +26,7 @@ const form = reactive({
 const fieldErrors = ref<ScheduleFieldErrors>({})
 
 const levels = computed(() =>
-  (layout.value?.levels ?? [])
-    .filter((level) => level.elementCount > 0)
-    .map((level) => ({
-      ...level,
-      label: humanizeKind(level.kind),
-    })),
+  (layout.value?.levels ?? []).filter((level) => level.elementCount > 0),
 )
 
 const scheduleFormSchema = z
@@ -111,12 +106,6 @@ async function retry(): Promise<void> {
     await setLayoutStore.fetchSetLayout(currentSetId.value)
   }
 }
-
-function humanizeKind(kind: string): string {
-  const words = kind.replaceAll(/[_-]+/g, ' ')
-
-  return words.charAt(0).toUpperCase() + words.slice(1)
-}
 </script>
 
 <template>
@@ -163,7 +152,7 @@ function humanizeKind(kind: string): string {
             >
               <option :value="null">Choose a level</option>
               <option v-for="level in levels" :key="level.id" :value="level.id">
-                {{ level.label }} ({{ level.elementCount }})
+                {{ level.kind }} ({{ level.elementCount }})
               </option>
             </select>
             <p v-if="fieldErrors.levelId" id="schedule-level-error" class="field-error">
diff --git a/frontend/website/src/views/DashboardView.vue b/frontend/website/src/views/DashboardView.vue
index a2ccaf5..12464ee 100644
--- a/frontend/website/src/views/DashboardView.vue
+++ b/frontend/website/src/views/DashboardView.vue
@@ -15,12 +15,6 @@ onMounted(async () => {
   await Promise.all([setsStore.fetchSets(), schedulesStore.fetchSchedules()])
 })
 
-function humanizeKind(kind: string): string {
-  const words = kind.replaceAll(/[_-]+/g, ' ')
-
-  return words.charAt(0).toUpperCase() + words.slice(1)
-}
-
 function formatDate(value: string): string {
   return new Intl.DateTimeFormat('en', {
     dateStyle: 'medium',
@@ -73,7 +67,7 @@ function formatDate(value: string): string {
           >
             <article class="schedule-card">
               <div class="schedule-card__heading">
-                <p>{{ humanizeKind(schedule.elementKind) }}</p>
+                <p class="schedule-card__kind">{{ schedule.elementKind }}</p>
                 <span>{{ schedule.assignmentCount }} assignments</span>
               </div>
               <h3>{{ schedule.set.name }}</h3>
@@ -310,6 +304,10 @@ h1 {
   margin: 0;
 }
 
+.schedule-card__kind {
+  text-transform: none;
+}
+
 .schedule-card h3 {
   margin: 2rem 0 0;
   font-family: Georgia, 'Times New Roman', serif;
diff --git a/frontend/website/src/views/ScheduleDetailView.vue b/frontend/website/src/views/ScheduleDetailView.vue
index fe430b4..352f44f 100644
--- a/frontend/website/src/views/ScheduleDetailView.vue
+++ b/frontend/website/src/views/ScheduleDetailView.vue
@@ -39,28 +39,6 @@ function formatDate(value: string): string {
     timeZone: 'UTC',
   }).format(new Date(`${value}T00:00:00Z`))
 }
-
-function humanizeKind(kind: string): string {
-  const words = kind.replaceAll(/[_-]+/g, ' ')
-
-  return words.charAt(0).toUpperCase() + words.slice(1)
-}
-
-function pluralKind(kind: string, count: number): string {
-  if (count === 1) {
-    return kind
-  }
-
-  if (kind.endsWith('y')) {
-    return `${kind.slice(0, -1)}ies`
-  }
-
-  if (kind.endsWith('s')) {
-    return kind
-  }
-
-  return `${kind}s`
-}
 </script>
 
 <template>
@@ -87,11 +65,14 @@ function pluralKind(kind: string, count: number): string {
 
       <template v-else-if="activeSchedule !== null">
         <header class="schedule-introduction">
-          <p class="eyebrow">{{ humanizeKind(activeSchedule.elementKind) }} plan</p>
+          <p class="eyebrow">
+            <span class="schedule-kind">{{ activeSchedule.elementKind }}</span> plan
+          </p>
           <h1>{{ activeSchedule.set.name }} schedule</h1>
           <p class="schedule-summary">
             {{ activeSchedule.assignmentCount }}
-            {{ pluralKind(activeSchedule.elementKind, activeSchedule.assignmentCount) }} across
+            {{ activeSchedule.elementKind }}
+            {{ activeSchedule.assignmentCount === 1 ? 'assignment' : 'assignments' }} across
             {{ activeSchedule.days.length }}
             {{ activeSchedule.days.length === 1 ? 'day' : 'days' }}
           </p>
@@ -119,7 +100,7 @@ function pluralKind(kind: string, count: number): string {
             <ul v-else class="assignment-list">
               <li v-for="assignment in day.assignments" :key="assignment.id">
                 <span class="assignment-path">{{ assignment.element.path.join(' / ') }}</span>
-                <span class="assignment-kind">{{ humanizeKind(assignment.element.kind) }}</span>
+                <span class="assignment-kind">{{ assignment.element.kind }}</span>
               </li>
             </ul>
           </li>
@@ -173,6 +154,10 @@ function pluralKind(kind: string, count: number): string {
   text-transform: uppercase;
 }
 
+.schedule-kind {
+  text-transform: none;
+}
+
 h1 {
   margin: 0;
   font-family: Georgia, 'Times New Roman', serif;
@@ -265,7 +250,7 @@ h1 {
   font-size: 0.62rem;
   font-weight: 800;
   letter-spacing: 0.1em;
-  text-transform: uppercase;
+  text-transform: none;
 }
 
 .page-state {

From 974d57ba155e40f9d99bf3aaaa8707142597d034 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Fri, 14 Aug 2026 09:55:09 +0300
Subject: [PATCH 22/25] document verbatim kind labels

---
 ai/frontend-context.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ai/frontend-context.md b/ai/frontend-context.md
index a2acb1e..1d2997c 100644
--- a/ai/frontend-context.md
+++ b/ai/frontend-context.md
@@ -57,6 +57,9 @@ backend and does not proxy the frontend.
 - Keep application-wide resets and base styles in `src/styles/main.css`.
   Keep component and view styles scoped and match established Attainly visual
   patterns.
+- Display user-authored set level kinds verbatim. Do not capitalize, replace
+  separators, pluralize, or apply `text-transform` to a kind value; pluralize
+  surrounding interface words such as "assignment" instead.
 - Inspect similar files before introducing a component, composable, store,
   route, or data-access pattern.
 

From 14eeee9e9922070f896a072ef6bc593413331df4 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Fri, 14 Aug 2026 09:58:51 +0300
Subject: [PATCH 23/25] stabilize schedule kind assertion

---
 frontend/website/cypress/e2e/set-scheduling.cy.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/frontend/website/cypress/e2e/set-scheduling.cy.ts b/frontend/website/cypress/e2e/set-scheduling.cy.ts
index 3c715a7..5747d6b 100644
--- a/frontend/website/cypress/e2e/set-scheduling.cy.ts
+++ b/frontend/website/cypress/e2e/set-scheduling.cy.ts
@@ -210,8 +210,11 @@ describe('set scheduling', () => {
     cy.wait('@schedule')
     cy.get('h1').should('have.text', 'Bible schedule')
     cy.get('.eyebrow')
-      .should('have.text', 'Chapter_sections-v2 plan')
+      .should(($eyebrow) => {
+        expect($eyebrow.text().trim()).to.equal('Chapter_sections-v2 plan')
+      })
       .find('.schedule-kind')
+      .should('have.text', 'Chapter_sections-v2')
       .should('have.css', 'text-transform', 'none')
     cy.contains('2 Chapter_sections-v2 assignments across 3 days').should('be.visible')
 

From bde48331de2c95e828f8646c01c7f511554adab3 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Fri, 14 Aug 2026 09:58:55 +0300
Subject: [PATCH 24/25] remove obsolete schema assertions

---
 backend/tests/Feature/Schedule/ScheduleEndpointTest.php | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
index e3aca06..0303dfe 100644
--- a/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
+++ b/backend/tests/Feature/Schedule/ScheduleEndpointTest.php
@@ -23,7 +23,6 @@ use App\User\UserRepository;
 use DateTimeImmutable;
 use DateTimeZone;
 use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Facades\Schema;
 use Illuminate\Testing\TestResponse;
 use Tests\TestCase;
 
@@ -151,12 +150,6 @@ class ScheduleEndpointTest extends TestCase
             'position' => 1,
         ]);
         $this->assertDatabaseCount('schedule_assignments', 2);
-        $this->assertFalse(Schema::hasColumn('schedules', 'set_id'));
-        $this->assertFalse(Schema::hasColumn('schedules', 'set_level_id'));
-        $this->assertFalse(Schema::hasColumn(
-            'schedule_assignments',
-            'element_id',
-        ));
 
         $this->credentialedGet('/api/schedules/1')
             ->assertOk()

From f683f46c3e8589c9ba42e9d23b7651f84d1ef0c8 Mon Sep 17 00:00:00 2001
From: Yisroel Baum <yisroel.d.baum@gmail.com>
Date: Fri, 14 Aug 2026 09:59:01 +0300
Subject: [PATCH 25/25] document behavior focused schema tests

---
 ai/backend-context.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ai/backend-context.md b/ai/backend-context.md
index 9850c44..7fc2f71 100644
--- a/ai/backend-context.md
+++ b/ai/backend-context.md
@@ -69,6 +69,9 @@ intentionally unclaimed; the built-in health endpoint is `/up`.
   relevant authorization guard instead of duplicating all business branches.
 - Place endpoint tests under `tests/Feature/<Area>/`, extend
   `Tests\TestCase`, and use `RefreshDatabase` when database state is involved.
+- Do not keep tests that only assert an obsolete column or other removed
+  schema detail is absent. Such assertions may verify a removal while it is
+  being developed, but discard them afterward and retain behavioral coverage.
 - Development and runtime use PostgreSQL through the local Unix socket.
   PHPUnit uses SQLite `:memory:` as configured in `phpunit.xml`, so feature
   tests are self-contained and do not need the worktree stack.