diff --git a/.claude/rules/auth.md b/.claude/rules/auth.md
index 1a330eb36..569103cb8 100644
--- a/.claude/rules/auth.md
+++ b/.claude/rules/auth.md
@@ -1,8 +1,10 @@
 ---
 description: Authentication rules
-globs:
+paths:
   - 'src/lib/server/auth.ts'
   - 'src/routes/(auth)/**'
+  - 'src/routes/(admin)/_utils/auth.ts'
+  - 'src/routes/(admin)/**'
   - 'src/hooks.server.ts'
 ---
 
@@ -30,6 +32,9 @@ globs:
 
 - `src/lib/server/auth.ts`: Lucia configuration
 - `src/hooks.server.ts`: Global request handler
+- `src/routes/(admin)/_utils/auth.ts`:
+  - `validateAdminAccess(locals)` — for page routes; redirects to `/login` for both unauthenticated and non-admin users (do not use in `+server.ts`)
+  - `validateAdminAccessForApi(locals)` — for API routes (`+server.ts`); throws `error(401)` if unauthenticated, `error(403)` if not admin
 - `prisma/schema.prisma`: User, Session, Key models
 
 ## Security
diff --git a/.claude/rules/coding-style.md b/.claude/rules/coding-style.md
new file mode 100644
index 000000000..454db270b
--- /dev/null
+++ b/.claude/rules/coding-style.md
@@ -0,0 +1,48 @@
+# Coding Style
+
+## Naming
+
+- **Abbreviations**: avoid non-standard abbreviations (`res` → `response`, `btn` → `button`). When in doubt, spell it out.
+- **Lambda parameters**: no single-character names (e.g., use `placement`, `workbook`). Iterator index `i` is the only exception.
+- **`upsert`**: only use when the implementation performs both insert and update. For insert-only, use `initialize`, `seed`, or another accurate verb.
+- **`any`**: before using `any`, check the value's origin — adding a missing `@types/*` or `devDependency` often provides the correct type.
+- **UI labels**: if a label does not match actual behavior, update it or add an inline comment explaining the intentional mismatch.
+
+## Syntax
+
+- **Braces**: always use braces for single-statement `if` blocks. Never `if () return;` — write `if () { return; }`.
+- **Plural type aliases**: define `type Placements = Placement[]` instead of using `Placement[]` directly in signatures and variables.
+
+## Markdown Code Blocks
+
+Always specify a language identifier on every fenced code block. Never write bare ` ``` `.
+
+Common identifiers: `typescript`, `svelte`, `sql`, `bash`, `mermaid`, `json`, `prisma`, `html`, `css`.
+
+## SvelteKit: Routes vs API Endpoints
+
+- Page routes (`+page.server.ts`): use `redirect()` to navigate
+- API routes (`+server.ts`): use `error()` — throwing `redirect()` returns a 3xx response; `fetch` follows it by default and receives the HTML page at the redirect target instead of a JSON error
+
+## Dual-Enforcement Constraints
+
+When the same constraint is enforced in two layers (e.g. Zod validation + SQL `CHECK`), add an inline comment stating each layer's role and the obligation to keep them in sync:
+
+```typescript
+// XOR constraint: dual enforcement via Zod (early validation) and a CHECK in migration.sql (last line of defence).
+// Prisma lacks @@check, so the SQL constraint is maintained manually. Keep both in sync.
+.refine(...)
+```
+
+## Async Rollback: Capture State Before `await`
+
+Capture `$state` values before the first `await` for safe rollback. A concurrent update can overwrite the variable while awaiting:
+
+```typescript
+const previous = items; // capture before await
+try {
+  await saveToServer(items);
+} catch {
+  items = previous;
+}
+```
diff --git a/.claude/rules/prisma-db.md b/.claude/rules/prisma-db.md
index b54f3612c..6f464f8b3 100644
--- a/.claude/rules/prisma-db.md
+++ b/.claude/rules/prisma-db.md
@@ -1,9 +1,10 @@
 ---
 description: Prisma and database rules
-globs:
+paths:
   - 'prisma/**'
   - 'src/lib/server/**'
   - 'src/lib/services/**'
+  - 'src/features/**/services/**'
 ---
 
 # Prisma & Database
@@ -11,30 +12,58 @@ globs:
 ## Schema Changes
 
 1. Edit `prisma/schema.prisma`
-2. Run `pnpm exec prisma migrate dev --name <description>` to create migration
-3. Run `pnpm exec prisma generate` to update client (auto-runs after migrate)
+2. Run `pnpm exec prisma migrate dev --name <snake_case_description>`
 
 ## Naming
 
-- Model names: `PascalCase` (e.g., `User`, `TaskAnswer`)
-- Field names: `camelCase` (preferred) or `snake_case` (legacy)
-- Relation fields: Descriptive names matching the relation
-
-## Key Models
-
-- `User`: User accounts with AtCoder validation status
-- `Task`: Tasks with difficulty grades (Q11-D6)
-- `TaskAnswer`: User submission status per task
-- `WorkBook`: task collections
-- `Tag` / `TaskTag`: task categorization
+- Models: `PascalCase` | Fields: `camelCase` (preferred) or `snake_case` (legacy)
 
 ## Server-Only Code
 
-- Import database client only in `src/lib/server/`
-- Use `$lib/server/database` for Prisma client access
+- Import DB client only in `src/lib/server/` via `$lib/server/database`
 - Never import server code in client components
 
+## Service Layer
+
+- All CRUD through the service layer (`src/lib/services/` or `src/features/**/services/`)
+- Route handlers call service methods — no direct Prisma in `+server.ts` / `+page.server.ts`
+- Service functions return pure values (`{ error: string } | null`), never `Response` / `json()`
+
 ## Transactions
 
-- Use `prisma.$transaction()` for multi-step operations
-- Handle errors with try-catch and proper rollback
+Use `prisma.$transaction()` for multi-step operations.
+
+## N+1 Queries
+
+Replace per-item DB calls in loops with a bulk fetch + `Map`:
+
+```typescript
+const records = await prisma.foo.findMany({ where: { id: { in: ids } } });
+const map = new Map(records.map((r) => [r.id, r]));
+```
+
+## Enum Types
+
+Prisma-generated enums and app-defined enums are distinct TypeScript types even with identical members. Keep explicit casts at the boundary — do not remove them as "redundant".
+
+## Idempotent Writes
+
+Prefer `createMany({ skipDuplicates: true })` over catching P2002 for expected unique violations (e.g., double-submit). Maps to `INSERT ... ON CONFLICT DO NOTHING`. Top-level only (not nested); PostgreSQL/CockroachDB/SQLite only.
+
+## Zod Schema for Int Fields
+
+`z.number().positive()` passes decimals. For Prisma `Int` fields use `z.number().int().positive()`.
+
+## Validate Constraints
+
+Prisma does not support `@@check`. To add one:
+
+1. `pnpm exec prisma migrate dev --create-only --name <description>` — generate migration without applying
+2. Edit the generated `migration.sql` to add the CHECK constraint manually
+3. `pnpm exec prisma migrate dev` — apply
+
+Document the constraint in `prisma/ERD.md` (the only place it's visible):
+
+```mermaid
+%% XOR constraint: workbookplacement_xor_grade_category — exactly one of taskGrade or solutionCategory must be non-null
+```
diff --git a/.claude/rules/svelte-components.md b/.claude/rules/svelte-components.md
index 099ffa3c2..4903254c4 100644
--- a/.claude/rules/svelte-components.md
+++ b/.claude/rules/svelte-components.md
@@ -1,6 +1,6 @@
 ---
 description: Svelte component development rules
-globs:
+paths:
   - 'src/**/*.svelte'
   - 'src/lib/components/**'
   - 'src/lib/stores/**/*.svelte.ts'
@@ -10,12 +10,7 @@ globs:
 
 ## Runes Mode (Required)
 
-- Use `$props()` for component props
-- Use `$state()` for reactive state
-- Use `$derived()` for computed values
-- Use `$effect()` for side effects
-
-## Props Pattern
+Use `$props()`, `$state()`, `$derived()`, `$effect()` in all components. Props pattern:
 
 ```svelte
 <script lang="ts">
@@ -23,24 +18,88 @@ globs:
     title: string;
     count?: number;
   }
-
   let { title, count = 0 }: Props = $props();
 </script>
 ```
 
-## Stores
+## File Naming
 
-- Place store files in `src/lib/stores/` with `.svelte.ts` extension
-- Use class-based stores with `$state()` for internal state
-- Export singleton instances
+- Components: `PascalCase.svelte`
+- Stores: `snake_case.svelte.ts` in `src/lib/stores/`, class-based with `$state()`, export singleton. Pre-Runes stores (using `writable()`, `.ts` extension) must be migrated to this pattern before adding features or extending them.
 
 ## Flowbite Svelte
 
-- Import components from `flowbite-svelte`
-- Use Tailwind CSS v4 utility classes
-- Dark mode: Use `dark:` prefix for dark mode variants
+Import from `flowbite-svelte`. Use Tailwind CSS v4 utility classes. Dark mode: `dark:` prefix.
 
-## File Naming
+## `$state()` Initialization with `$props()`
 
-- Components: `PascalCase.svelte`
-- Stores: `snake_case.svelte.ts`
+Referencing `$props()` inside `$state()` initializer triggers "This reference only captures the initial value". Wrap with `untrack` if intentional:
+
+```svelte
+let count = $state(untrack(() => initialCount)); // intentional: prop is initial seed only
+```
+
+## `{#snippet}` Placement
+
+Define snippets at the **top level**, outside component tags. Inside a tag = named slot = type error:
+
+```svelte
+<!-- Good -->
+{#snippet footer()}...{/snippet}
+<Dialog {footer} />
+
+<!-- Bad: named slot, not a snippet prop -->
+<Dialog>{#snippet footer()}...{/snippet}</Dialog>
+```
+
+## Snippet vs Component
+
+Prefer `{#snippet}` when: (1) needs direct `$state` access, (2) pure display only, (3) same-file DRY.
+Promote to component when: independent state/lifecycle needed, exceeds ~30 lines, or reused across files.
+
+## Component Boundaries
+
+- One component, one responsibility: don't mix display, state management, and data fetching
+- Extract `$derived`/`$effect` logic exceeding ~5 lines to a custom store
+- Extract repeated UI patterns (2+ uses) to a snippet or component (see Snippet vs Component)
+
+## Keep Components Thin
+
+Business logic and pure utilities belong outside `<script>` blocks — in the nearest `utils/` (or `_utils/` for routes), with adjacent unit tests. See `docs/guides/architecture.md` for layer-specific placement.
+
+## Pure Functions and Side Effect Separation
+
+Extract business logic as pure functions to `utils/` (or `_utils/` for routes); keep side effects in the caller:
+
+```typescript
+// Pure function in _utils/ — testable, no side effects
+export function buildUpdatedUrl(url: URL, activeTab: ActiveTab): URL { ... }
+
+// Side effect stays in the caller
+replaceState(buildUpdatedUrl($page.url, activeTab), {});
+```
+
+## Empty-list Fallback in `{#each}`
+
+Use `{:else}` to render a placeholder when the list is empty — no wrapper conditional needed:
+
+```svelte
+{#each items as item (item.id)}
+  <Card {item} />
+{:else}
+  <p>No items yet.</p>
+{/each}
+```
+
+## Eliminate Branching with Records
+
+Replace `if`/ternary chains with `Record<EnumType, T>`:
+
+```typescript
+const TAB_CONFIGS: Record<ActiveTab, TabConfig> = {
+  curriculum: { label: 'Curriculum', ... },
+  solution:   { label: 'Solution',   ... },
+};
+```
+
+Use the enum type as the key type, not `string`.
diff --git a/.claude/rules/testing.md b/.claude/rules/testing.md
index 6e9f19554..cd9b06c5e 100644
--- a/.claude/rules/testing.md
+++ b/.claude/rules/testing.md
@@ -1,6 +1,6 @@
 ---
 description: Testing rules and patterns
-globs:
+paths:
   - '**/*.test.ts'
   - '**/*.spec.ts'
   - 'tests/**'
@@ -9,46 +9,75 @@ globs:
 
 # Testing
 
+## Test Integrity
+
+- Never delete, comment out, or weaken assertions (e.g. `toEqual` → `toBeDefined`) to make tests pass
+- Fix the implementation, not the test; if the test itself is wrong, explain why in a comment or commit message
+
 ## Test Types
 
-| Type        | Tool       | Location                | Run Command             |
-| ----------- | ---------- | ----------------------- | ----------------------- |
-| Unit        | Vitest     | `src/test/**/*.test.ts` | `pnpm test:unit`        |
-| Integration | Vitest     | `src/test/`             | `pnpm test:unit`        |
-| E2E         | Playwright | `tests/*.test.ts`       | `pnpm test:integration` |
+| Type | Tool       | Location                                                          | Run Command             |
+| ---- | ---------- | ----------------------------------------------------------------- | ----------------------- |
+| Unit | Vitest     | `src/test/` (mirrors `src/lib/`) or co-located in `src/features/` | `pnpm test:unit`        |
+| E2E  | Playwright | `tests/`                                                          | `pnpm test:integration` |
+
+## Assertions
+
+- Use `toBe(true)` / `toBe(false)` over `toBeTruthy()` / `toBeFalsy()`
+- For DB query tests, assert `orderBy`, `include`, and other significant parameters with `expect.objectContaining` — not just `where`
+- Enum membership: `in` traverses the prototype chain; use `Object.hasOwn(Enum, value)` instead
 
-## Unit Tests
+## Cleanup in Tests
+
+Wrap DB-mutating cleanup in `try/finally` — a failing assertion skips cleanup and contaminates later tests:
+
+```typescript
+try {
+  await doSomething();
+  expect(result).toBe(expected);
+} finally {
+  await restoreState();
+}
+```
 
-- Place tests in `src/test/` mirroring `src/lib/` structure
-- Use `@quramy/prisma-fabbrica` for test data factories
-- Mock external APIs with Nock
+## Test Data
 
-## E2E Tests
+- Use realistic fixture values (real task IDs, grade names) instead of placeholders like `'t1'`
+- Extract shared data into fixture files; inline is fine for single-use cases
+- After `.filter()` on fixtures, verify actual contents — same ID may refer to a different entity after fixture updates
 
-- Place in `tests/` directory
-- Use Playwright test utilities
-- Test user flows, not implementation details
+## Mock Helpers
 
-## Patterns
+Extract repeated mock patterns into a helper in the test file:
 
 ```typescript
-import { describe, test, expect, vi } from 'vitest';
-
-describe('functionName', () => {
-  test('expects to do something', () => {
-    // Arrange
-    // Act
-    // Assert
-  });
-});
+function mockFindMany(value: WorkBookPlacements) {
+  vi.mocked(prisma.workBookPlacement.findMany).mockResolvedValue(
+    value as unknown as Awaited<ReturnType<typeof prisma.workBookPlacement.findMany>>,
+  );
+}
 ```
 
+## Testing Extracted Utilities
+
+- Add tests at extraction time, not later
+- For URL manipulation: assert the original URL is not mutated
+- For multi-column operations (e.g., DnD): assert both source and destination columns
+
 ## Coverage
 
 - Run `pnpm coverage` for coverage report
 - Target: 80% lines, 70% branches
 
+## Service Layer Split for Testability
+
+When a service file mixes DB operations and pure functions, split it into two files:
+
+- `crud.ts` — DB operations (`getXxx`, `updateXxx`, `createXxx`); tests need Prisma mocks
+- `initializers.ts` — pure computation (grade grouping, priority assignment); tests need no mocks
+
+Stop the split if internal helpers (e.g. `fetchUnplacedWorkbooks`) would be fragmented across files — cohesion matters more than the split itself.
+
 ## HTTP Mocking
 
-- Use Nock for mocking external HTTP calls
-- See `src/test/lib/clients/` for examples
+Use Nock for external HTTP calls. See `src/test/lib/clients/` for examples.
diff --git a/.claude/skills/refactor-plan/SKILL.md b/.claude/skills/refactor-plan/SKILL.md
new file mode 100644
index 000000000..46141ec29
--- /dev/null
+++ b/.claude/skills/refactor-plan/SKILL.md
@@ -0,0 +1,13 @@
+---
+name: refactor-plan
+description: Analyze a GitHub issue or file path and produce a phased refactoring plan. Outputs a TODO list only — does not make code changes.
+disable-model-invocation: true
+argument-hint: '[issue-number | file-path]'
+---
+
+Produce a refactoring plan for: $ARGUMENTS
+
+1. **Gather context** — number: `gh issue view $ARGUMENTS --comments` (if `gh` unavailable, fetch the issue via WebFetch); path: read source files under that path
+2. **Investigate** — read relevant source files; apply the checklist in [instructions.md](instructions.md)
+3. **Plan** — group findings into phases (lowest → highest risk); each phase is a `- [ ]` checklist; note inter-phase dependencies
+4. **Stop — output the plan only. Do not implement any changes.**
diff --git a/.claude/skills/refactor-plan/instructions.md b/.claude/skills/refactor-plan/instructions.md
new file mode 100644
index 000000000..d988a3eaf
--- /dev/null
+++ b/.claude/skills/refactor-plan/instructions.md
@@ -0,0 +1,64 @@
+# Refactoring Investigation Checklist
+
+Scan the target code in this order (lowest risk first). List every concrete finding — do not skip ambiguous cases.
+
+## 1. Naming and Style
+
+- Abbreviated/single-character names (`res`, `btn`, etc.) → expand to full names
+- Single-statement `if` without braces → add braces
+- Hardcoded string literals matching enum values → replace with enum constants
+- `toBeTruthy()` / `toBeFalsy()` in tests → replace with `toBe(true)` / `toBe(false)`
+
+## 2. Type Definitions
+
+- `Hoge[]` in signatures → define a plural type alias
+- Inline union literals repeated in multiple places → extract to a named type
+- Function argument types broader than needed → narrow to minimum fields used
+
+## 3. Pure Function Extraction
+
+- Side effects mixed with business logic → extract logic as a pure function to `utils/` (use `_utils/` inside `src/routes/`; same rule applies below)
+- Extracted `utils/` functions with no adjacent tests → add tests at extraction time
+
+## 4. Component Bloat
+
+- Static constants inside `<script>` → move to `utils/`
+- Transformation/calculation logic inside `<script>` → move to `utils/`
+- `if (activeTab === '...')` branching → replace with `Record<EnumKey, Config>`
+- Snippet vs. component cases → apply `.claude/rules/svelte-components.md` criteria
+
+## 5. Service Layer Structure
+
+- DB query + business logic + DB write in one function → split by responsibility
+- Route handlers or `seed.ts` calling Prisma directly → delegate to service layer
+- Service functions returning `Response` or `json()` → change to `{ error: string } | null`
+
+## 6. Test Coverage
+
+- Abstract test data (`'t1'`, `'t2'`) → replace with real fixture values
+- Test data duplicated across cases → extract to a fixture file
+- Repeated `vi.mocked(...).mockResolvedValue(...)` patterns → extract to a helper
+- `utils/` functions with no adjacent tests → add tests
+
+## 7. Documentation (always last)
+
+- New patterns not yet in `.claude/rules/` → note which rule file to update
+- Record key decisions in dev-note; discard completed plans after the session
+
+---
+
+## Phase Design Principles
+
+- Order phases by risk: isolated mechanical changes first, structural changes last
+- State inter-phase dependencies explicitly
+- For uncertain changes, add an **investigation sub-step** before the implementation task
+
+## When to Skip Tests
+
+Skip unit tests when:
+
+- The function has no logic (e.g., `if (!res.ok) throw`)
+- The target is `seed.ts` (integration-level scope)
+- Testing requires mocking the entire framework (auth redirects, DnD events)
+
+Note "covered by E2E" or "no testable logic" next to these tasks.
diff --git a/AGENTS.md b/AGENTS.md
index d03ba1f39..818436226 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -6,6 +6,15 @@ A web service for tracking submissions on AtCoder and other competitive programm
 
 Always prefer simplicity over pathological correctness. YAGNI, KISS, DRY. No backward-compat shims or fallback paths unless they come free without adding cyclomatic complexity.
 
+**When implementing:**
+
+1. Plan with a phased TODO list before starting (lower risk → higher risk order)
+2. Before writing a new function, search `src/lib/utils/`, `src/lib/services/`, `src/features/*/utils/` and `src/features/*/services/` for existing implementations; extract shared logic there when it appears in 2+ places
+3. Write tests first, then implement production code, then verify with `pnpm test:unit`
+4. Review critically after implementing: flag YAGNI violations, over-abstraction, missing tests
+5. Record reusable insights in `.claude/rules/` or `docs/guides/` after the session
+6. Discard or summarize completed plans; don't leave stale TODOs
+
 ## Tech Stack
 
 SvelteKit 2 + Svelte 5 (Runes) + TypeScript | PostgreSQL + Prisma | Flowbite Svelte + Tailwind 4 | Vitest + Playwright
@@ -42,6 +51,16 @@ src/lib/
 ├── types/ # TypeScript types
 ├── utils/ # Pure utility functions
 └── zod/ # Validation schemas
+src/features/ # Feature-scoped code (single domain)
+├── {feature}/
+│ ├── components/ # Feature UI (list/, detail/, shared/)
+│ ├── fixtures/ # Test data
+│ ├── services/ # Feature business logic (CRUD via Prisma)
+│ │ └── _.test.ts # Tests co-located next to source (not in src/test/)
+│ ├── stores/ # Feature stores
+│ ├── types/ # Feature types
+│ └── utils/ # Feature utilities
+│ └── _.test.ts # Tests co-located next to source
 src/test/ # Unit tests (mirrors src/lib/)
 tests/ # E2E tests (Playwright)
 prisma/schema.prisma # Database schema
@@ -52,7 +71,7 @@ prisma/schema.prisma # Database schema
 - **Svelte 5 Runes**: Use `$props()`, `$state()`, `$derived()` in all new components
 - **Server data**: `+page.server.ts` → `+page.svelte` via `data` prop
 - **Forms**: Superforms + Zod validation
-- **Tests**: Factories via `@quramy/prisma-fabbrica`, HTTP mocking via Nock
+- **Tests**: Write tests before implementation (TDD). Use `@quramy/prisma-fabbrica` for factories, Nock for HTTP mocking
 - **Naming**: `camelCase` variables, `PascalCase` types/components, `snake_case` files/routes, `kebab-case` directories
 - **Pre-commit**: Lefthook runs Prettier + ESLint (bypass: `LEFTHOOK=0 git commit`)
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3a032bb5f..f65983a3c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -31,6 +31,7 @@
 - UIライブラリ
   - [Flowbite Svelte](https://flowbite-svelte.com/) - コンポーネントライブラリ
     - [Flowbite](https://flowbite.com/)も利用可能
+  - [@dnd-kit/svelte](https://dndkit.com/svelte) - Svelte 5 ネイティブ対応のドラッグ&ドロップライブラリ（管理者向け: 問題集の並び順を管理するカンバンボードで使用。Flowbite Svelte では、同一のパネル内での並び替えができないことが判明したため）
   - [Lucide](https://github.com/lucide-icons/lucide) - アイコンライブラリ
 - テスティングフレームワーク
   - [Vitest](https://vitest.dev/): 単体テスト (ユーティリティ、コンポーネント)
diff --git a/docs/dev-notes/2026-02-28/workbook-order/plan.md b/docs/dev-notes/2026-02-28/workbook-order/plan.md
new file mode 100644
index 000000000..39b28e6f9
--- /dev/null
+++ b/docs/dev-notes/2026-02-28/workbook-order/plan.md
@@ -0,0 +1,115 @@
+# 実装メモ: 問題集の並び順管理 (Issue #943)
+
+## Context
+
+管理者が問題集（CURRICULUM / SOLUTION）の表示順序をカンバンボードで DnD 管理できるようにする。
+
+**スコープ**: カンバン管理画面のみ。ユーザー向け `/workbooks` への表示順反映は別 Issue。
+
+---
+
+## 主要な設計判断
+
+| 項目                           | 決定と理由                                                                                                                             |
+| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
+| DB 設計                        | `WorkBookPlacement` テーブルに `solutionCategory` / `taskGrade` / `priority` を集約（WorkBook 本体を汚さない）                         |
+| XOR 制約                       | Zod refinement（早期検証）+ migration.sql の CHECK 制約（最終防壁）の二重管理。Prisma に `@@check` がないため migration.sql に手動追記 |
+| CURRICULUM↔SOLUTION 間移動禁止 | `createDroppable` の `accept` プロパティ + サーバー側でも `workBookType` チェック（多重防御）                                          |
+| priority 再計算                | 連番振り直し（1, 2, 3…）。Lexorank は管理者1人の本用途では YAGNI                                                                       |
+| 保存タイミング                 | ドロップ時即時保存。楽観的更新 + 失敗時ロールバック + Toast                                                                            |
+| 状態管理                       | URL パラメータ（`?tab=solution&categories=PENDING,GRAPH`）で管理。localStorage は SSR との hydration mismatch リスクあり               |
+| 初期化トリガー                 | form action の POST で実行。`load()` 内で DB INSERT は HTTP セマンティクス違反（GET の副作用）                                         |
+| API エンドポイント             | `+server.ts`（JSON API）。DnD は `fetch(JSON)` なので form action は不適（`request.formData()` を期待するため 415 になる）             |
+
+---
+
+## 非自明な実装上の決定
+
+### `@@unique([taskGrade, priority])` を採用しない理由
+
+`prisma.$transaction()` 内での順次 UPDATE は中間状態で UNIQUE 制約違反が発生する（PostgreSQL はトランザクション内でも各 SQL 文ごとに即時チェック）。管理者のみが操作するため同時実行が発生せず、DB レベルの複合ユニーク制約は不要。
+
+### バルク操作の規模感
+
+- 初期化: 約120件の `createMany`
+- ドロップ時: `prisma.$transaction()` + 個別 update（最大200件）
+- いずれも管理者専用で問題ない規模
+
+---
+
+## @dnd-kit/svelte 実装上の注意点
+
+- **`onDragOver` で `move()` を呼ぶ必須**: `onDragEnd` のみだと `{#each}` の DOM と `OptimisticSortingPlugin` が不整合でフリーズ
+- **object getter パターン必須**: `createSortable({ get id() { return placement.id }, get index() { return i }, get group() { return columnId }, get type() { return group } })` — `id` / `index` だけでなく `group` / `type` も同様。内部で `$effect.pre` を使うため、通常の値渡しはスナップショットになり prop 変更が追跡されない
+- **`createSortable` はコンポーネントトップレベルで**: `{#each}` 内の `{@const}` で呼ぶとリアクティブ再評価でフリーズ
+- **sortable `id` にプレフィックス禁止**: `move()` が `item.id === source.id` で照合するため
+- **`use:action` 型の適合**: `attach(node)` の戻り値 `() => void` を `{ destroy: () => void }` にラップして Svelte アクション型に合わせる
+- **`accept`（単数形）**: droppable の型フィルタは `accept`。`accepts` は存在しない
+- **`@dnd-kit/dom` / `@dnd-kit/abstract` を devDependencies に追加**: `@dnd-kit/svelte` のイベントハンドラ型を正しく使うために必要
+- **`move()` はカラム割り当てを更新しない**: 配列順序のみ変更。クロスカラム移動では `onDragEnd` で `solutionCategory` / `taskGrade` を明示的に更新する必要がある
+- **初期表示は `priority` でソートすること**: `load()` が `workBook.id` 昇順を返しても `priority` は別の値になりうる。`buildInitialCards` で `priority` ソートを行わないと DnD 永続化の確認ができない
+
+---
+
+## 主要バグと対処方法
+
+### Bug 1: DB に保存されない（415 Unsupported Media Type）
+
+**原因**: `KanbanBoard.svelte` の `onDragEnd` が `Content-Type: application/json` でフォームアクション（`?/updatePlacements`）に fetch。フォームアクションは `request.formData()` を期待するため 415 エラー。
+
+**対処**: `+server.ts` を新規作成し JSON API エンドポイントとして実装。fetch URL を `/workbooks/order` に変更。
+
+### Bug 2: URL パラメータに解法別・カリキュラムの値が混在する
+
+**原因**: タブ切り替え時に相手方のパラメータをリセットしていない。
+
+**対処**: タブ切り替え時に `updateUrl()` で反対側のパラメータを削除（solution → `grades` 削除、curriculum → `categories` 削除）。
+
+### Bug 3: `move()` がカードのカラム割り当てを更新しない
+
+**原因**: `@dnd-kit/helpers` の `move()` は配列順序のみ変更し、`solutionCategory` / `taskGrade` プロパティを更新しない。`onDragEnd` での `updates` 構築時に古いカラム値のまま送信される。
+
+**対処**: `onDragEnd` 内、`updates` 構築前にドラッグされたカードのカラムフィールドを明示的に更新する。
+
+### Bug 4: Playwright の `page.request.post()` が `+server.ts` に届かない
+
+**原因**: `page.request` はブラウザのクッキーを共有するが SvelteKit のルーティングでフォームアクションに落ちて 415 になるケースがある。
+
+**対処**: `page.evaluate(() => fetch(...))` でブラウザコンテキストから呼ぶ。
+
+### 参考ドキュメント
+
+- [SvelteKit Form Actions](https://svelte.dev/docs/kit/form-actions) — フォームアクションの仕組み
+- [SvelteKit Routing - server](https://svelte.dev/docs/kit/routing#server) — `+server.ts` の仕様
+- [Playwright Locators](https://playwright.dev/docs/locators) — ロケータの優先順位
+
+---
+
+## 教訓
+
+### DnD
+
+- DnD ライブラリが更新するのは**配列順序のみ**。クロスカラム移動では `onDragEnd` で明示的にプロパティを更新する
+- Playwright の mouse 操作は `@dnd-kit`（ポインターイベント）と不整合。E2E テストは `page.evaluate(() => fetch(...))` で API を直接呼び出す
+- DnD カード内のインタラクティブ要素は `onclick` と `onpointerdown` の両方を `stopPropagation` する（`@dnd-kit` の Pointer センサーは `pointerdown` でドラッグを開始するため）
+
+### Prisma / DB
+
+- バリデーションループに DB 呼び出しが入ったら N+1 を疑い、`findMany({ where: { id: { in: ids } } })` + `Map` パターンに置き換える
+- Prisma enum とアプリ enum は構造が同じでも TypeScript は別型として扱う。キャストが必要な箇所を残すこと
+
+### Svelte 5
+
+- `use:action` の戻り値は `{ destroy: cleanup }` の形で返す（Svelte アクション型に合わせるため）
+- snippet 維持の目安: コンポーネント化で props が10個以上になるなら snippet のまま
+
+### テスト
+
+- URL パース + バリデーションは `URLSearchParams` を引数に取る純粋関数に切り出す（単体テスト可能になる。デフォルト値も関数内に定数として定義する）
+
+### コードレビュー（AI）
+
+- AI 指摘は実コードで検証してから判断する。null 安全性（データフロー全体を追う）・enum のランタイム利用パターンなどは誤検知しやすい
+- 「アルゴリズム非効率」指摘は本番ホットパス・N+1 が対象のときだけ有効。管理者専用・シードへの `find()` → `Map` 化は YAGNI
+- リファクタリング指摘（行数・責務過多、共通化余地）は実装の意図を確認してから判断する。ロジック抽出済みのグルーコード・構造が異なる関数群への適用は誤検知になる
+- レビューで参照されるファイルパスは実在確認が必要
diff --git a/docs/guides/architecture.md b/docs/guides/architecture.md
index 404ea93f0..187906a6d 100644
--- a/docs/guides/architecture.md
+++ b/docs/guides/architecture.md
@@ -56,7 +56,9 @@ src/features/
 │   ├── fixtures/                    # テスト用データ
 │   ├── services/
 │   │   ├── workbooks.ts
-│   │   └── workbooks.test.ts
+│   │   ├── workbooks.test.ts
+│   │   ├── workbook_placements.ts   # WorkBookPlacement の取得・更新・新規の問題集を追加
+│   │   └── workbook_placements.test.ts
 │   ├── stores/
 │   │   └── active_workbook_tab.ts
 │   ├── types/
@@ -89,6 +91,32 @@ src/features/
 - `detail/` — 詳細ページ用コンポーネント
 - `shared/` — feature 内で複数ページから使うコンポーネント
 
+### ルート固有の `_types/` / `_utils/` ディレクトリ
+
+SvelteKit のルートディレクトリ内で、そのページ専用の型やユーティリティを colocate するために `_types/` と `_utils/` を使う。アンダースコアプレフィックスにより SvelteKit のルーティング対象外となる。
+
+```text
+src/routes/(admin)/workbooks/order/
+├── +page.svelte
+├── +page.server.ts
+├── +server.ts
+├── _components/        # ページ専用コンポーネント
+│   ├── KanbanBoard.svelte
+│   └── ...
+├── _types/             # ページ専用の型定義
+│   └── kanban.ts
+└── _utils/             # ページ専用のユーティリティ（純粋関数）
+    ├── kanban.ts
+    └── kanban.test.ts  # ユーティリティにはテストを隣接配置
+```
+
+**ルール:**
+
+- `_types/` には型定義のみ置く。ランタイムコードは含めない
+- `_utils/` には純粋関数のみ置く。副作用やサーバー専用コードは含めない
+- `_utils/` の関数には単体テストを隣接配置する
+- 他のルートから参照する場合は `features/` または `lib/` に昇格させる
+
 ### Feature 分割案
 
 現在の `src/lib/` からの抽出候補:
diff --git a/docs/guides/claude-code.md b/docs/guides/claude-code.md
new file mode 100644
index 000000000..9a278ee0c
--- /dev/null
+++ b/docs/guides/claude-code.md
@@ -0,0 +1,114 @@
+# Claude Code 機能ガイド
+
+Claude Code の拡張ポイントの使い分けをまとめる。
+
+## 機能の概要と使い分け
+
+| 機能                      | 場所                    | 読み込みタイミング                                                 | 主な用途                                           |
+| ------------------------- | ----------------------- | ------------------------------------------------------------------ | -------------------------------------------------- |
+| `CLAUDE.md` / `AGENTS.md` | プロジェクトルート      | セッション開始時・常時                                             | プロジェクト全体の規約・コマンド                   |
+| `.claude/rules/*.md`      | `.claude/rules/`        | `paths` 指定なし → 常時、`paths` 指定あり → 対象ファイルを開いた時 | トピック別ルール（コーディングスタイル・テスト等） |
+| Skills (`/skill-name`)    | `.claude/skills/`       | 呼び出し時のみ                                                     | 再利用可能なワークフロー手順                       |
+| Hooks                     | `.claude/settings.json` | ツール呼び出しイベント時                                           | 自動フォーマット・保護ファイルブロック等の自動処理 |
+
+## 各機能の詳細
+
+### CLAUDE.md / AGENTS.md
+
+- セッション開始時に全文読み込まれる（トークン消費）
+- **200行以内を目安**にする
+- プロジェクト全体に常に適用したい規約・コマンド一覧・アーキテクチャ概要を置く
+- `CLAUDE.md` から `@AGENTS.md` のように別ファイルを読み込める
+
+### `.claude/rules/` ファイル
+
+- フロントマターで `paths` を指定すると、対象ファイルを開いた時だけ読み込まれる（コンテキスト節約）
+- `paths` を指定しないと常時読み込まれる（CLAUDE.md と同じ扱い）
+- **`globs` は非推奨。`paths` を使う**
+
+```yaml
+---
+description: Testing rules and patterns
+paths:
+  - '**/*.test.ts'
+  - 'tests/**'
+---
+```
+
+適しているもの:
+
+- Linter/Formatter でカバーできない「意思決定ルール」（アーキテクチャ方針、命名判断基準）
+- ファイル種別ごとに分けたい規約（テスト、DB、Svelte コンポーネント等）
+
+**このプロジェクトの rules ファイル:**
+
+| ファイル               | スコープ                                                 |
+| ---------------------- | -------------------------------------------------------- |
+| `coding-style.md`      | 言語レベルの記述スタイル（ブレース・命名・型エイリアス） |
+| `testing.md`           | `*.test.ts`, `tests/**` のテストパターン                 |
+| `svelte-components.md` | `*.svelte` コンポーネント設計方針                        |
+| `prisma-db.md`         | `prisma/**`, `src/lib/server/**` の DB・サービス層規約   |
+| `auth.md`              | 認証関連                                                 |
+
+### Skills（カスタムスラッシュコマンド）
+
+- `/skill-name` で呼び出す再利用可能な手順書
+- 呼び出し時のみフル読み込みされるためコンテキストに優しい
+- CLAUDE.md に常時書くほどではないが、繰り返し使うワークフローに向く
+
+**ビルトイン skills（`~/.claude/skills/`）:**
+
+| スキル      | 用途                               |
+| ----------- | ---------------------------------- |
+| `/commit`   | git コミット作成ワークフロー       |
+| `/simplify` | 変更済みコードの品質レビュー・改善 |
+
+**本プロジェクトの skills（`.claude/skills/`）:**
+
+| スキル           | 用途                                                                   |
+| ---------------- | ---------------------------------------------------------------------- |
+| `/refactor-plan` | Issue 番号またはパスを渡してリファクタリング計画を出力（実装はしない） |
+
+### Hooks
+
+- `PreToolUse` / `PostToolUse` 等のイベントで自動実行されるシェルコマンド
+- LLM の判断を介さず**確実に**実行される（deterministic）
+- `.claude/settings.json` の `hooks` セクションに設定
+
+適しているもの:
+
+- **コード編集後の自動フォーマット**（PostToolUse: Edit/Write → `pnpm format`）
+- 保護すべきファイルへの書き込みブロック
+- 通知
+
+> **このプロジェクトでは** Lefthook が pre-commit で Prettier + ESLint を実行するため、
+> hooks による PostToolUse フォーマットは必須ではない。
+> 編集中にリアルタイムでフォーマットしたい場合のみ hooks を検討する。
+
+## 既存ツールで十分なもの
+
+以下は **Linter / Formatter / CI で既にカバーされている**ため、Claude Code の機能で重複して設定しない:
+
+| 問題                 | 対応ツール                                 |
+| -------------------- | ------------------------------------------ |
+| コードフォーマット   | Prettier（Lefthook で pre-commit 実行）    |
+| 未使用変数・型エラー | ESLint + `pnpm check`（Svelte 型チェック） |
+| ブレース強制         | ESLint `curly` ルールで対応可能            |
+| import 順序          | ESLint で対応可能                          |
+
+## 作業フロー規約
+
+Claude Code を使ってリファクタリング・機能追加を行う際の標準フロー:
+
+1. **計画**: `plan.md`（またはドキュメントの TODO セクション）にフェーズ分けした TODO リストを作成する
+2. **実装**: プロダクションコード → テスト → `pnpm test:unit` で確認
+3. **TODO 更新**: 完了タスクにチェックを入れる
+4. **レビュー**: 実装後に批判的な観点でレビューする（忖度しない。YAGNI / KISS / DRY 違反、過剰な抽象化を指摘する）
+5. **教訓整理**: 次回以降も有用な知見を `.claude/rules/` または `docs/guides/` などに記録する
+6. **クリーンアップ**: 完了した計画書・古い TODO は削除または要約する
+
+## 参考
+
+- [Claude Code 公式ドキュメント](https://docs.anthropic.com/en/docs/claude-code)
+- [CLAUDE.md の書き方](https://docs.anthropic.com/en/docs/claude-code/memory)
+- [Hooks の設定](https://docs.anthropic.com/en/docs/claude-code/hooks)
diff --git a/package.json b/package.json
index 431072970..4338d9d9c 100644
--- a/package.json
+++ b/package.json
@@ -23,6 +23,8 @@
     "coverage": "vitest run --coverage"
   },
   "devDependencies": {
+    "@dnd-kit/abstract": "0.3.2",
+    "@dnd-kit/dom": "0.3.2",
     "@eslint/eslintrc": "3.3.5",
     "@eslint/js": "9.39.4",
     "@playwright/test": "1.58.2",
@@ -68,6 +70,8 @@
   },
   "type": "module",
   "dependencies": {
+    "@dnd-kit/helpers": "0.3.2",
+    "@dnd-kit/svelte": "0.3.2",
     "@lucia-auth/adapter-prisma": "3.0.2",
     "@lucide/svelte": "0.577.0",
     "@mermaid-js/mermaid-cli": "11.12.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 24e17d164..39d80e3ca 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,6 +8,12 @@ importers:
 
   .:
     dependencies:
+      '@dnd-kit/helpers':
+        specifier: 0.3.2
+        version: 0.3.2
+      '@dnd-kit/svelte':
+        specifier: 0.3.2
+        version: 0.3.2(svelte@5.53.12)
       '@lucia-auth/adapter-prisma':
         specifier: 3.0.2
         version: 3.0.2(@prisma/client@5.22.0(prisma@5.22.0))(lucia@2.7.7)
@@ -60,6 +66,12 @@ importers:
         specifier: 1.0.15
         version: 1.0.15
     devDependencies:
+      '@dnd-kit/abstract':
+        specifier: 0.3.2
+        version: 0.3.2
+      '@dnd-kit/dom':
+        specifier: 0.3.2
+        version: 0.3.2
       '@eslint/eslintrc':
         specifier: 3.3.5
         version: 3.3.5
@@ -330,6 +342,29 @@ packages:
     resolution: {integrity: sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==}
     engines: {node: '>=20.19.0'}
 
+  '@dnd-kit/abstract@0.3.2':
+    resolution: {integrity: sha512-uvPVK+SZYD6Viddn9M0K0JQdXknuVSxA/EbMlFRanve3P/XTc18oLa5zGftKSGjfQGmuzkZ34E26DSbly1zi3Q==}
+
+  '@dnd-kit/collision@0.3.2':
+    resolution: {integrity: sha512-pNmNSLCI8S9fNQ7QJ3fBCDjiT0sqBhUFcKgmyYaGvGCAU+kq0AP8OWlh0JSisc9k5mFyxmRpmFQcnJpILz/RPA==}
+
+  '@dnd-kit/dom@0.3.2':
+    resolution: {integrity: sha512-cIUAVgt2szQyz6JRy7I+0r+xeyOAGH21Y15hb5bIyHoDEaZBvIDH+OOlD9eoLjCbsxDLN9WloU2CBi3OE6LYDg==}
+
+  '@dnd-kit/geometry@0.3.2':
+    resolution: {integrity: sha512-3UBPuIS7E3oGiHxOE8h810QA+0pnrnCtGxl4Os1z3yy5YkC/BEYGY+TxWPTQaY1/OMV7GCX7ZNMlama2QN3n3w==}
+
+  '@dnd-kit/helpers@0.3.2':
+    resolution: {integrity: sha512-pj7pCE6BiysNetpPnzb3BJOrcKiqueUr1LFg6wYoi2fIFYpz66n2Ojd7HTwfwkpv0oyC3QlvA6Dk8cOmi6VavA==}
+
+  '@dnd-kit/state@0.3.2':
+    resolution: {integrity: sha512-dLUIkoYrIJhGXfF2wGLTfb46vUokEsO/OoE21TSfmahYrx7ysTmnwbePsznFaHlwgZhQEh6AlLvthLCeY21b1A==}
+
+  '@dnd-kit/svelte@0.3.2':
+    resolution: {integrity: sha512-HkTnx/3GnxfVNqHSojxhxp5r+KymL9Q7UI2gonXN2+bmdObw03FSQOjicOoRzlV2u9o5DtK1sU4YUQAfkLCGGQ==}
+    peerDependencies:
+      svelte: ^5.29.0
+
   '@edge-runtime/format@2.2.1':
     resolution: {integrity: sha512-JQTRVuiusQLNNLe2W9tnzBlV/GvSVcozLl4XZHk5swnRZ/v6jp8TqR8P7sqmJsQqblDZ3EztcWmLDbhRje/+8g==}
     engines: {node: '>=16'}
@@ -1221,6 +1256,9 @@ packages:
   '@poppinss/macroable@1.1.0':
     resolution: {integrity: sha512-y/YKzZDuG8XrpXpM7Z1RdQpiIc0MAKyva24Ux1PB4aI7RiSI/79K8JVDcdyubriTm7vJ1LhFs8CrZpmPnx/8Pw==}
 
+  '@preact/signals-core@1.13.0':
+    resolution: {integrity: sha512-slT6XeTCAbdql61GVLlGU4x7XHI7kCZV5Um5uhE4zLX4ApgiiXc0UYFvVOKq06xcovzp7p+61l68oPi563ARKg==}
+
   '@prisma/client@5.22.0':
     resolution: {integrity: sha512-M0SVXfyHnQREBKxCgyo7sffrKttwE6R8PMq330MIUF0pTwjUhLbW84pFDlf06B27XyCR++VtjugEnIHdr07SVA==}
     engines: {node: '>=16.13'}
@@ -5549,6 +5587,49 @@ snapshots:
 
   '@csstools/css-tokenizer@4.0.0': {}
 
+  '@dnd-kit/abstract@0.3.2':
+    dependencies:
+      '@dnd-kit/geometry': 0.3.2
+      '@dnd-kit/state': 0.3.2
+      tslib: 2.8.1
+
+  '@dnd-kit/collision@0.3.2':
+    dependencies:
+      '@dnd-kit/abstract': 0.3.2
+      '@dnd-kit/geometry': 0.3.2
+      tslib: 2.8.1
+
+  '@dnd-kit/dom@0.3.2':
+    dependencies:
+      '@dnd-kit/abstract': 0.3.2
+      '@dnd-kit/collision': 0.3.2
+      '@dnd-kit/geometry': 0.3.2
+      '@dnd-kit/state': 0.3.2
+      tslib: 2.8.1
+
+  '@dnd-kit/geometry@0.3.2':
+    dependencies:
+      '@dnd-kit/state': 0.3.2
+      tslib: 2.8.1
+
+  '@dnd-kit/helpers@0.3.2':
+    dependencies:
+      '@dnd-kit/abstract': 0.3.2
+      tslib: 2.8.1
+
+  '@dnd-kit/state@0.3.2':
+    dependencies:
+      '@preact/signals-core': 1.13.0
+      tslib: 2.8.1
+
+  '@dnd-kit/svelte@0.3.2(svelte@5.53.12)':
+    dependencies:
+      '@dnd-kit/abstract': 0.3.2
+      '@dnd-kit/dom': 0.3.2
+      '@dnd-kit/state': 0.3.2
+      svelte: 5.53.12
+      tslib: 2.8.1
+
   '@edge-runtime/format@2.2.1': {}
 
   '@edge-runtime/node-utils@2.3.0': {}
@@ -6181,6 +6262,8 @@ snapshots:
   '@poppinss/macroable@1.1.0':
     optional: true
 
+  '@preact/signals-core@1.13.0': {}
+
   '@prisma/client@5.22.0(prisma@5.22.0)':
     optionalDependencies:
       prisma: 5.22.0
diff --git a/prisma/ERD.md b/prisma/ERD.md
index c1e1e2d86..d60e4edc5 100644
--- a/prisma/ERD.md
+++ b/prisma/ERD.md
@@ -87,6 +87,26 @@ THEME THEME
 OTHERS OTHERS
         }
     
+
+
+        SolutionCategory {
+            PENDING PENDING
+SEARCH_SIMULATION SEARCH_SIMULATION
+DYNAMIC_PROGRAMMING DYNAMIC_PROGRAMMING
+DATA_STRUCTURE DATA_STRUCTURE
+GRAPH GRAPH
+TREE TREE
+NUMBER_THEORY NUMBER_THEORY
+ALGEBRA ALGEBRA
+COMBINATORICS COMBINATORICS
+GAME GAME
+STRING STRING
+GEOMETRY GEOMETRY
+OPTIMIZATION OPTIMIZATION
+OTHERS OTHERS
+ANALYSIS ANALYSIS
+        }
+    
   "user" {
     String id "🗝️"
     String username 
@@ -196,6 +216,17 @@ OTHERS OTHERS
     }
   
 
+  "workbookplacement" {
+    Int id "🗝️"
+    Int workBookId 
+    TaskGrade taskGrade "❓"
+    SolutionCategory solutionCategory "❓"
+    Int priority 
+    DateTime createdAt 
+    DateTime updatedAt 
+    }
+  
+
   "workbooktask" {
     String id "🗝️"
     Int workBookId 
@@ -219,6 +250,9 @@ OTHERS OTHERS
     "taskanswer" }o--|o submissionstatus : "status"
     "workbook" |o--|| "WorkBookType" : "enum:workBookType"
     "workbook" }o--|| user : "user"
+    "workbookplacement" |o--|o "TaskGrade" : "enum:taskGrade"
+    "workbookplacement" |o--|o "SolutionCategory" : "enum:solutionCategory"
+    "workbookplacement" |o--|| workbook : "workBook"
     "workbooktask" }o--|| workbook : "workBook"
     "workbooktask" }o--|| task : "task"
 ```
diff --git a/prisma/migrations/20260301060623_add_workbook_placement/migration.sql b/prisma/migrations/20260301060623_add_workbook_placement/migration.sql
new file mode 100644
index 000000000..9000c6a92
--- /dev/null
+++ b/prisma/migrations/20260301060623_add_workbook_placement/migration.sql
@@ -0,0 +1,29 @@
+-- CreateEnum
+CREATE TYPE "SolutionCategory" AS ENUM ('PENDING', 'SEARCH_SIMULATION', 'DYNAMIC_PROGRAMMING', 'DATA_STRUCTURE', 'GRAPH', 'TREE', 'NUMBER_THEORY', 'ALGEBRA', 'COMBINATORICS', 'GAME', 'STRING', 'GEOMETRY', 'OPTIMIZATION', 'OTHERS', 'ANALYSIS');
+
+-- CreateTable
+CREATE TABLE "workbookplacement" (
+    "id" SERIAL NOT NULL,
+    "workBookId" INTEGER NOT NULL,
+    "taskGrade" "TaskGrade",
+    "solutionCategory" "SolutionCategory",
+    "priority" INTEGER NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "workbookplacement_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "workbookplacement_workBookId_key" ON "workbookplacement"("workBookId");
+
+-- AddForeignKey
+ALTER TABLE "workbookplacement" ADD CONSTRAINT "workbookplacement_workBookId_fkey" FOREIGN KEY ("workBookId") REFERENCES "workbook"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddCheckConstraint (XOR: taskGrade と solutionCategory はどちらか片方のみ non-null)
+ALTER TABLE "workbookplacement"
+ADD CONSTRAINT "workbookplacement_xor_grade_category"
+CHECK (
+  ("taskGrade" IS NOT NULL AND "solutionCategory" IS NULL)
+  OR ("taskGrade" IS NULL AND "solutionCategory" IS NOT NULL)
+);
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 83b6ab1cb..a0edd4aee 100755
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -201,10 +201,26 @@ model WorkBook {
   user User @relation(references: [id], fields: [authorId])
 
   workBookTasks WorkBookTask[]
+  placement     WorkBookPlacement?
 
   @@map("workbook")
 }
 
+// Note: 問題集（カリキュラム、解法別）の並び替えで使用
+model WorkBookPlacement {
+  id               Int               @id @default(autoincrement())
+  workBookId       Int               @unique
+  taskGrade        TaskGrade? // CURRICULUM 用（SOLUTION は null）
+  solutionCategory SolutionCategory? // SOLUTION 用（CURRICULUM は null）
+  priority         Int // 1以上。1に近いほど上側に表示
+  createdAt        DateTime          @default(now())
+  updatedAt        DateTime          @updatedAt
+
+  workBook WorkBook @relation(references: [id], fields: [workBookId], onDelete: Cascade)
+
+  @@map("workbookplacement")
+}
+
 model WorkBookTask {
   id         String   @id @default(uuid())
   workBookId Int
@@ -294,3 +310,21 @@ enum WorkBookType {
   THEME // (Deprecated) テーマ別: さまざまな解法 (解法別より狭義) を横断し得るものをまとめている
   OTHERS // (Deprecated) 上記以外
 }
+
+enum SolutionCategory {
+  PENDING // 未分類
+  SEARCH_SIMULATION // 探索・シミュレーション・実装
+  DYNAMIC_PROGRAMMING // 動的計画法
+  DATA_STRUCTURE // データ構造
+  GRAPH // グラフ
+  TREE // 木
+  NUMBER_THEORY // 数学（整数論）
+  ALGEBRA // 数学（代数）
+  COMBINATORICS // 数え上げ・確率・期待値
+  GAME // ゲーム
+  STRING // 文字列
+  GEOMETRY // 幾何
+  OPTIMIZATION // 最適化
+  OTHERS // その他
+  ANALYSIS // 考察テクニック
+}
diff --git a/prisma/seed.ts b/prisma/seed.ts
index ccb58bb7d..4dfc9984e 100755
--- a/prisma/seed.ts
+++ b/prisma/seed.ts
@@ -22,6 +22,7 @@ import PQueue from 'p-queue';
 import { generateLuciaPasswordHash } from 'lucia/utils';
 
 import { getTaskGrade } from '../src/lib/types/task';
+import type { PlacementCreate } from '../src/features/workbooks/types/workbook_placement';
 
 import { classifyContest } from '../src/lib/utils/contest';
 
@@ -29,6 +30,14 @@ import { users, USER_PASSWORD_FOR_SEED } from './users';
 import { tasks } from './tasks';
 import { contest_task_pairs } from './contest_task_pairs';
 import { workbooks } from '../src/features/workbooks/fixtures/workbooks';
+import { solutionCategoryMap } from '../src/features/workbooks/fixtures/solution_category_map';
+import {
+  buildTaskMapFromCurriculumRows,
+  buildCurriculumWorkbooksForInit,
+  initializeCurriculumPlacements,
+  initializeSolutionPlacements,
+} from '../src/features/workbooks/services/workbook_placements/initializers';
+import { createWorkBookPlacements } from '../src/features/workbooks/services/workbook_placements/crud';
 import { tags } from './tags';
 import { task_tags } from './task_tags';
 import { answers } from './answers';
@@ -64,6 +73,7 @@ async function main() {
     await addTasks();
     await addContestTaskPairs();
     await addWorkBooks();
+    await addWorkBookPlacements();
     await addTags();
     await addTaskTags();
     await addSubmissionStatuses();
@@ -304,6 +314,62 @@ async function addWorkBooks() {
   console.log('Finished adding workbooks.');
 }
 
+async function addWorkBookPlacements() {
+  console.log('Start adding workbook placements...');
+
+  const [unplacedCurriculum, unplacedSolution] = await Promise.all([
+    prisma.workBook.findMany({
+      where: { workBookType: 'CURRICULUM', placement: null },
+      include: {
+        workBookTasks: { include: { task: { select: { task_id: true, grade: true } } } },
+      },
+      orderBy: { id: 'asc' },
+    }),
+    prisma.workBook.findMany({
+      where: { workBookType: 'SOLUTION', placement: null },
+      orderBy: { id: 'asc' },
+    }),
+  ]);
+
+  await addCurriculumPlacements(unplacedCurriculum);
+  await addSolutionPlacements(unplacedSolution);
+
+  console.log('Finished adding workbook placements.');
+}
+
+async function addCurriculumPlacements(
+  unplacedCurriculum: Parameters<typeof buildTaskMapFromCurriculumRows>[0],
+) {
+  if (unplacedCurriculum.length === 0) {
+    return;
+  }
+
+  const tasksMapByIds = buildTaskMapFromCurriculumRows(unplacedCurriculum);
+  const workbooksForInit = buildCurriculumWorkbooksForInit(unplacedCurriculum);
+  const placements = initializeCurriculumPlacements(workbooksForInit, tasksMapByIds);
+
+  await createWorkBookPlacements(placements);
+  console.log(`Added ${placements.length} curriculum placements.`);
+}
+
+async function addSolutionPlacements(unplacedSolution: { id: number; urlSlug: string | null }[]) {
+  if (unplacedSolution.length === 0) {
+    return;
+  }
+
+  // Apply solutionCategoryMap overrides; workbooks not listed default to PENDING.
+  const placements = initializeSolutionPlacements(unplacedSolution).map(
+    (placement: PlacementCreate) => {
+      const workbooks = unplacedSolution.find((workbook) => workbook.id === placement.workBookId);
+      const category = workbooks?.urlSlug ? solutionCategoryMap[workbooks.urlSlug] : undefined;
+      return { ...placement, solutionCategory: category ?? 'PENDING' };
+    },
+  );
+
+  await createWorkBookPlacements(placements);
+  console.log(`Added ${placements.length} solution placements.`);
+}
+
 async function addWorkBook(
   workbook: (typeof workbooks)[number],
   workBookFactory: ReturnType<typeof defineWorkBookFactory>,
diff --git a/src/features/workbooks/components/shared/WorkbookLink.svelte b/src/features/workbooks/components/shared/WorkbookLink.svelte
new file mode 100644
index 000000000..00c734053
--- /dev/null
+++ b/src/features/workbooks/components/shared/WorkbookLink.svelte
@@ -0,0 +1,17 @@
+<script lang="ts">
+  interface Props {
+    workBookId: number;
+    title: string;
+  }
+
+  let { workBookId, title }: Props = $props();
+</script>
+
+<a
+  href="/workbooks/{workBookId}"
+  class="text-sm font-medium text-primary-600 hover:underline dark:text-primary-500"
+  onclick={(e) => e.stopPropagation()}
+  onpointerdown={(e) => e.stopPropagation()}
+>
+  {title}
+</a>
diff --git a/src/features/workbooks/fixtures/solution_category_map.ts b/src/features/workbooks/fixtures/solution_category_map.ts
new file mode 100644
index 000000000..c6d2d1b78
--- /dev/null
+++ b/src/features/workbooks/fixtures/solution_category_map.ts
@@ -0,0 +1,17 @@
+import { SolutionCategory } from '$features/workbooks/types/workbook_placement';
+
+/**
+ * Maps urlSlug → SolutionCategory for seeding.
+ * SOLUTION workbooks not listed here are initially placed as PENDING.
+ */
+export const solutionCategoryMap: Record<string, SolutionCategory> = {
+  'greedy-method': SolutionCategory.SEARCH_SIMULATION,
+  'recursive-function': SolutionCategory.SEARCH_SIMULATION,
+  'bitmask-brute-force-search': SolutionCategory.SEARCH_SIMULATION,
+  'map-dict': SolutionCategory.DATA_STRUCTURE,
+  stack: SolutionCategory.DATA_STRUCTURE,
+  'ordered-set': SolutionCategory.DATA_STRUCTURE,
+  'priority-queue': SolutionCategory.DATA_STRUCTURE,
+  'potentialized-union-find': SolutionCategory.GRAPH,
+  'number-theory-search': SolutionCategory.NUMBER_THEORY,
+};
diff --git a/src/features/workbooks/fixtures/workbook_placements.ts b/src/features/workbooks/fixtures/workbook_placements.ts
new file mode 100644
index 000000000..5476166a7
--- /dev/null
+++ b/src/features/workbooks/fixtures/workbook_placements.ts
@@ -0,0 +1,215 @@
+import { TaskGrade, type Task } from '$lib/types/task';
+import { WorkBookType } from '$features/workbooks/types/workbook';
+import {
+  SolutionCategory,
+  type WorkBookPlacements,
+  type WorkbooksWithPlacement,
+  type WorkBooksWithTasks,
+  type UnplacedCurriculumRows,
+} from '$features/workbooks/types/workbook_placement';
+
+// ---------------------------------------------------------------------------
+// Placement records (WorkBookPlacement shape)
+// ---------------------------------------------------------------------------
+
+// CURRICULUM placements reflecting seed data order:
+//   workBook 1: 標準入出力（1 個の整数）→ tasks Q10: math_and_algorithm_a, tessoku_book_a, ...
+//   workBook 2: 標準入出力（2 個以上の整数）→ tasks Q9: tessoku_book_bz, abc169_a, ...
+//   workBook 6: if 文 ① → tasks Q8: abc174_a, abc334_a, ...
+export const curriculumPlacements: WorkBookPlacements = [
+  { id: 1, workBookId: 1, taskGrade: TaskGrade.Q10, solutionCategory: null, priority: 1 },
+  { id: 2, workBookId: 2, taskGrade: TaskGrade.Q9, solutionCategory: null, priority: 1 },
+  { id: 6, workBookId: 6, taskGrade: TaskGrade.Q8, solutionCategory: null, priority: 1 },
+];
+
+// SOLUTION placements reflecting solutionCategoryMap:
+//   stack (workBook 31) → DATA_STRUCTURE
+//   bitmask-brute-force-search (workBook 33) → SEARCH_SIMULATION
+//   number-theory-search (workBook 40) → NUMBER_THEORY
+//   unlisted workbook (workBook 99) → PENDING (state after createInitialPlacements runs; placement: null means not yet initialized)
+export const solutionPlacements: WorkBookPlacements = [
+  {
+    id: 101,
+    workBookId: 31,
+    taskGrade: null,
+    solutionCategory: SolutionCategory.DATA_STRUCTURE,
+    priority: 1,
+  },
+  {
+    id: 102,
+    workBookId: 33,
+    taskGrade: null,
+    solutionCategory: SolutionCategory.SEARCH_SIMULATION,
+    priority: 1,
+  },
+  {
+    id: 103,
+    workBookId: 40,
+    taskGrade: null,
+    solutionCategory: SolutionCategory.NUMBER_THEORY,
+    priority: 1,
+  },
+  {
+    id: 104,
+    workBookId: 99,
+    taskGrade: null,
+    solutionCategory: SolutionCategory.PENDING,
+    priority: 2,
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Workbooks with placements (returned by getWorkbooksWithPlacements)
+// ---------------------------------------------------------------------------
+
+export const workbooksWithPlacements: WorkbooksWithPlacement = [
+  {
+    id: 1,
+    title: '標準入出力（1 個の整数）',
+    isPublished: true,
+    workBookType: WorkBookType.CURRICULUM,
+    placement: curriculumPlacements[0],
+  },
+  {
+    id: 31,
+    title: 'スタック（stack）',
+    isPublished: true,
+    workBookType: WorkBookType.SOLUTION,
+    placement: solutionPlacements[0],
+  },
+  {
+    id: 99,
+    title: '未分類問題集',
+    isPublished: false,
+    workBookType: WorkBookType.SOLUTION,
+    placement: null,
+  },
+];
+
+// ---------------------------------------------------------------------------
+// DB row shapes used in validateAndUpdatePlacements tests
+// (WorkBookPlacement + workBook relation from Prisma include)
+// ---------------------------------------------------------------------------
+
+export const curriculumPlacementRow = {
+  ...curriculumPlacements[0],
+  workBook: { workBookType: WorkBookType.CURRICULUM },
+};
+
+export const solutionPlacementRow = {
+  ...solutionPlacements[0],
+  workBook: { workBookType: WorkBookType.SOLUTION },
+};
+
+// ---------------------------------------------------------------------------
+// Task map (used by initializeCurriculumPlacements tests)
+// Task IDs match those in fixtures/workbooks.ts CURRICULUM/SOLUTION workbooks
+// ---------------------------------------------------------------------------
+
+export const tasksMapByIds = new Map<string, Task>([
+  [
+    'math_and_algorithm_a',
+    {
+      task_id: 'math_and_algorithm_a',
+      contest_id: 'math_and_algorithm',
+      task_table_index: 'A',
+      title: '001. Print 5+N',
+      grade: TaskGrade.Q10,
+    },
+  ],
+  [
+    'tessoku_book_a',
+    {
+      task_id: 'tessoku_book_a',
+      contest_id: 'tessoku_book',
+      task_table_index: 'A',
+      title: 'A01. The First Problem',
+      grade: TaskGrade.Q10,
+    },
+  ],
+  [
+    'tessoku_book_bz',
+    {
+      task_id: 'tessoku_book_bz',
+      contest_id: 'tessoku_book',
+      task_table_index: 'BZ',
+      title: 'B01. A+B Problem',
+      grade: TaskGrade.Q9,
+    },
+  ],
+  [
+    'abc169_a',
+    {
+      task_id: 'abc169_a',
+      contest_id: 'abc169',
+      task_table_index: 'A',
+      title: 'A. Multiplication 1',
+      grade: TaskGrade.Q9,
+    },
+  ],
+  [
+    'abc174_a',
+    {
+      task_id: 'abc174_a',
+      contest_id: 'abc174',
+      task_table_index: 'A',
+      title: 'A. Air Conditioner',
+      grade: TaskGrade.Q8,
+    },
+  ],
+  [
+    'abc219_a',
+    {
+      task_id: 'abc219_a',
+      contest_id: 'abc219',
+      task_table_index: 'A',
+      title: 'A. AtCoder Judge',
+      grade: TaskGrade.Q10,
+    },
+  ],
+]);
+
+// ---------------------------------------------------------------------------
+// Curriculum workbooks for initializeCurriculumPlacements tests
+// (WorkBooksWithTasks shape — reflects fixtures/workbooks.ts entries 1, 2, 6, 7)
+// ---------------------------------------------------------------------------
+
+export const curriculumWorkbooksForInit: WorkBooksWithTasks = [
+  {
+    id: 1,
+    workBookTasks: [
+      { taskId: 'math_and_algorithm_a', priority: 1, comment: '' },
+      { taskId: 'tessoku_book_a', priority: 2, comment: '' },
+    ],
+  },
+  {
+    id: 2,
+    workBookTasks: [
+      { taskId: 'tessoku_book_bz', priority: 1, comment: '' },
+      { taskId: 'abc169_a', priority: 2, comment: '' },
+    ],
+  },
+  { id: 6, workBookTasks: [{ taskId: 'abc174_a', priority: 1, comment: '' }] },
+  { id: 7, workBookTasks: [{ taskId: 'abc219_a', priority: 1, comment: '' }] },
+];
+
+// ---------------------------------------------------------------------------
+// Unplaced workbook shapes for createInitialPlacements tests
+// (shapes returned by fetchUnplacedWorkbooks internals)
+// ---------------------------------------------------------------------------
+
+export const unplacedCurriculumRows: UnplacedCurriculumRows = [
+  {
+    id: 1,
+    workBookTasks: [
+      { task: { task_id: 'math_and_algorithm_a', grade: TaskGrade.Q10 } },
+      { task: { task_id: 'tessoku_book_a', grade: TaskGrade.Q10 } },
+    ],
+  },
+  {
+    id: 2,
+    workBookTasks: [{ task: { task_id: 'tessoku_book_bz', grade: TaskGrade.Q9 } }],
+  },
+];
+
+export const unplacedSolutionWorkbooks = [{ id: 31 }, { id: 33 }];
diff --git a/src/features/workbooks/services/workbook_placements/crud.test.ts b/src/features/workbooks/services/workbook_placements/crud.test.ts
new file mode 100644
index 000000000..11ae00e10
--- /dev/null
+++ b/src/features/workbooks/services/workbook_placements/crud.test.ts
@@ -0,0 +1,289 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+
+import { TaskGrade } from '$lib/types/task';
+import { WorkBookType } from '$features/workbooks/types/workbook';
+import {
+  SolutionCategory,
+  type WorkBookPlacements,
+} from '$features/workbooks/types/workbook_placement';
+
+import {
+  getWorkbooksWithPlacements,
+  getPlacementsByWorkBookType,
+  updateWorkBookPlacements,
+  createInitialPlacements,
+  validateAndUpdatePlacements,
+  createWorkBookPlacements,
+} from './crud';
+
+import {
+  curriculumPlacements,
+  solutionPlacements,
+  workbooksWithPlacements,
+  curriculumPlacementRow,
+  solutionPlacementRow,
+  unplacedCurriculumRows,
+  unplacedSolutionWorkbooks,
+} from '$features/workbooks/fixtures/workbook_placements';
+
+vi.mock('$lib/server/database', () => ({
+  default: {
+    workBook: {
+      findMany: vi.fn(),
+    },
+    workBookPlacement: {
+      findMany: vi.fn(),
+      update: vi.fn(),
+      createMany: vi.fn(),
+    },
+    $transaction: vi.fn(),
+  },
+}));
+
+import prisma from '$lib/server/database';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+function mockFindMany(placements: WorkBookPlacements) {
+  vi.mocked(prisma.workBookPlacement.findMany).mockResolvedValue(
+    placements as unknown as Awaited<ReturnType<typeof prisma.workBookPlacement.findMany>>,
+  );
+}
+
+function mockPlacementFindManyOnce(placements: WorkBookPlacements) {
+  vi.mocked(prisma.workBookPlacement.findMany).mockResolvedValueOnce(
+    placements as unknown as Awaited<ReturnType<typeof prisma.workBookPlacement.findMany>>,
+  );
+}
+
+function mockWorkBookFindManyOnce(result: { id: number }[]) {
+  vi.mocked(prisma.workBook.findMany).mockResolvedValueOnce(
+    result as unknown as Awaited<ReturnType<typeof prisma.workBook.findMany>>,
+  );
+}
+
+describe('getWorkbooksWithPlacements', () => {
+  test('returns workbooks of type CURRICULUM and SOLUTION with their placements', async () => {
+    mockWorkBookFindManyOnce(workbooksWithPlacements);
+
+    const result = await getWorkbooksWithPlacements();
+
+    expect(result).toEqual(workbooksWithPlacements);
+    expect(prisma.workBook.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          workBookType: { in: [WorkBookType.CURRICULUM, WorkBookType.SOLUTION] },
+        }),
+      }),
+    );
+  });
+});
+
+describe('getPlacementsByWorkBookType', () => {
+  test('returns CURRICULUM placements ordered by priority', async () => {
+    mockFindMany(curriculumPlacements);
+
+    const result = await getPlacementsByWorkBookType(WorkBookType.CURRICULUM);
+
+    // Verifies the function returns the DB result without transformation
+    expect(result).toEqual(curriculumPlacements);
+    expect(prisma.workBookPlacement.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ workBook: { workBookType: WorkBookType.CURRICULUM } }),
+        orderBy: { priority: 'asc' },
+      }),
+    );
+  });
+
+  test('returns SOLUTION placements ordered by priority', async () => {
+    mockFindMany(solutionPlacements);
+
+    const result = await getPlacementsByWorkBookType(WorkBookType.SOLUTION);
+
+    expect(result).toEqual(solutionPlacements);
+    expect(prisma.workBookPlacement.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ workBook: { workBookType: WorkBookType.SOLUTION } }),
+        orderBy: { priority: 'asc' },
+      }),
+    );
+  });
+
+  test('returns placements with multiple distinct solutionCategory values', async () => {
+    // Reflects the solutionCategoryMap fixture:
+    //   stack, potentialized-union-find, priority-queue, map-dict, ordered-set → DATA_STRUCTURE
+    //   bitmask-brute-force-search, greedy-method, recursive-function → SEARCH_SIMULATION
+    //   number-theory-search → NUMBER_THEORY
+    mockFindMany(solutionPlacements);
+
+    const result = await getPlacementsByWorkBookType(WorkBookType.SOLUTION);
+    const categories = result.map((placement) => placement.solutionCategory);
+
+    expect(categories).toContain(SolutionCategory.DATA_STRUCTURE);
+    expect(categories).toContain(SolutionCategory.SEARCH_SIMULATION);
+    expect(categories).toContain(SolutionCategory.NUMBER_THEORY);
+    expect(categories).toContain(SolutionCategory.PENDING);
+    expect(result.every((placement) => placement.taskGrade === null)).toBe(true);
+  });
+});
+
+describe('updateWorkBookPlacements', () => {
+  test('updates multiple placements within a transaction', async () => {
+    vi.mocked(prisma.$transaction).mockResolvedValue([]);
+
+    const updates = [
+      { id: 1, priority: 1, taskGrade: TaskGrade.Q10, solutionCategory: null },
+      { id: 2, priority: 2, taskGrade: TaskGrade.Q9, solutionCategory: null },
+    ];
+    await updateWorkBookPlacements(updates);
+
+    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not call transaction when given an empty array', async () => {
+    await updateWorkBookPlacements([]);
+    expect(prisma.$transaction).not.toHaveBeenCalled();
+  });
+
+  test('processes a batch containing both CURRICULUM and SOLUTION placements', async () => {
+    vi.mocked(prisma.$transaction).mockResolvedValue([]);
+
+    const updates = [
+      { id: 1, priority: 1, taskGrade: TaskGrade.Q10, solutionCategory: null },
+      { id: 2, priority: 2, taskGrade: TaskGrade.Q9, solutionCategory: null },
+      { id: 101, priority: 1, taskGrade: null, solutionCategory: SolutionCategory.DATA_STRUCTURE },
+      {
+        id: 102,
+        priority: 2,
+        taskGrade: null,
+        solutionCategory: SolutionCategory.SEARCH_SIMULATION,
+      },
+    ];
+    await updateWorkBookPlacements(updates);
+
+    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+    const callArg = vi.mocked(prisma.$transaction).mock.calls[0][0];
+    expect(Array.isArray(callArg)).toBe(true);
+    expect(callArg).toHaveLength(4);
+  });
+
+  test('updates solutionCategory from PENDING to a specific category', async () => {
+    vi.mocked(prisma.$transaction).mockResolvedValue([]);
+
+    // Simulates the admin moving a workbook from PENDING to DATA_STRUCTURE on the Kanban board
+    const updates = [
+      { id: 104, priority: 3, taskGrade: null, solutionCategory: SolutionCategory.DATA_STRUCTURE },
+    ];
+    await updateWorkBookPlacements(updates);
+
+    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('createInitialPlacements', () => {
+  test('does nothing when all workbooks are already placed', async () => {
+    mockWorkBookFindManyOnce([]); // unplaced CURRICULUM
+    mockWorkBookFindManyOnce([]); // unplaced SOLUTION
+
+    await createInitialPlacements();
+
+    expect(prisma.workBookPlacement.createMany).not.toHaveBeenCalled();
+  });
+
+  test('creates placements for unplaced curriculum and solution workbooks', async () => {
+    // unplacedCurriculumRows: 2 workbooks → 2 curriculum placements
+    // unplacedSolutionWorkbooks: 2 workbooks → 2 solution placements (PENDING)
+    mockWorkBookFindManyOnce(unplacedCurriculumRows);
+    mockWorkBookFindManyOnce(unplacedSolutionWorkbooks);
+    vi.mocked(prisma.workBookPlacement.createMany).mockResolvedValue({ count: 4 });
+
+    await createInitialPlacements();
+
+    expect(prisma.workBookPlacement.createMany).toHaveBeenCalledTimes(1);
+    const callArg = vi.mocked(prisma.workBookPlacement.createMany).mock.calls[0][0];
+    expect(callArg?.data).toHaveLength(4); // 2 curriculum + 2 solution
+  });
+
+  test('calls createMany with skipDuplicates to tolerate concurrent double-submit', async () => {
+    mockWorkBookFindManyOnce(unplacedCurriculumRows);
+    mockWorkBookFindManyOnce(unplacedSolutionWorkbooks);
+    vi.mocked(prisma.workBookPlacement.createMany).mockResolvedValue({ count: 4 });
+
+    await createInitialPlacements();
+
+    const callArg = vi.mocked(prisma.workBookPlacement.createMany).mock.calls[0][0];
+    expect(callArg?.skipDuplicates).toBe(true);
+  });
+});
+
+describe('validateAndUpdatePlacements', () => {
+  test('returns null and calls upsert when all updates are valid', async () => {
+    mockPlacementFindManyOnce([curriculumPlacementRow]);
+    vi.mocked(prisma.$transaction).mockResolvedValue([]);
+
+    const result = await validateAndUpdatePlacements([
+      { id: 1, priority: 2, taskGrade: TaskGrade.Q10, solutionCategory: null },
+    ]);
+
+    expect(result).toBeNull();
+    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('returns error when placement id does not exist', async () => {
+    mockPlacementFindManyOnce([]);
+
+    const result = await validateAndUpdatePlacements([
+      { id: 999, priority: 1, taskGrade: null, solutionCategory: SolutionCategory.GRAPH },
+    ]);
+
+    expect(result).toMatchObject({ error: expect.stringContaining('999') });
+    expect(prisma.$transaction).not.toHaveBeenCalled();
+  });
+
+  test('returns error for CURRICULUM → SOLUTION cross-type movement', async () => {
+    mockPlacementFindManyOnce([curriculumPlacementRow]);
+
+    const result = await validateAndUpdatePlacements([
+      { id: 1, priority: 1, taskGrade: null, solutionCategory: SolutionCategory.GRAPH },
+    ]);
+
+    expect(result).toMatchObject({ error: expect.stringContaining('not allowed') });
+    expect(prisma.$transaction).not.toHaveBeenCalled();
+  });
+
+  test('returns error for SOLUTION → CURRICULUM cross-type movement', async () => {
+    mockPlacementFindManyOnce([solutionPlacementRow]);
+
+    const result = await validateAndUpdatePlacements([
+      { id: 101, priority: 1, taskGrade: TaskGrade.Q10, solutionCategory: null },
+    ]);
+
+    expect(result).toMatchObject({ error: expect.stringContaining('not allowed') });
+    expect(prisma.$transaction).not.toHaveBeenCalled();
+  });
+});
+
+describe('createWorkBookPlacements', () => {
+  test('calls createMany when given placement data', async () => {
+    vi.mocked(prisma.workBookPlacement.createMany).mockResolvedValue({ count: 2 });
+
+    await createWorkBookPlacements([
+      { workBookId: 1, taskGrade: TaskGrade.Q10, solutionCategory: null, priority: 1 },
+      {
+        workBookId: 31,
+        taskGrade: null,
+        solutionCategory: SolutionCategory.DATA_STRUCTURE,
+        priority: 1,
+      },
+    ]);
+
+    expect(prisma.workBookPlacement.createMany).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not call createMany when given an empty array', async () => {
+    await createWorkBookPlacements([]);
+    expect(prisma.workBookPlacement.createMany).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/features/workbooks/services/workbook_placements/crud.ts b/src/features/workbooks/services/workbook_placements/crud.ts
new file mode 100644
index 000000000..3391deff2
--- /dev/null
+++ b/src/features/workbooks/services/workbook_placements/crud.ts
@@ -0,0 +1,180 @@
+import prisma from '$lib/server/database';
+
+import {
+  type WorkBookPlacement,
+  type WorkBookPlacements,
+  type WorkbooksWithPlacement,
+  type PlacementInputs,
+  type PlacementCreates,
+} from '$features/workbooks/types/workbook_placement';
+
+import { WorkBookType } from '$features/workbooks/types/workbook';
+
+import {
+  buildTaskMapFromCurriculumRows,
+  buildCurriculumWorkbooksForInit,
+  initializeCurriculumPlacements,
+  initializeSolutionPlacements,
+} from './initializers';
+
+// --- Basic CRUD operations for placements ---
+
+/**
+ * Returns all CURRICULUM and SOLUTION workbooks with their placements, ordered by id.
+ */
+export async function getWorkbooksWithPlacements(): Promise<WorkbooksWithPlacement> {
+  return prisma.workBook.findMany({
+    where: { workBookType: { in: [WorkBookType.CURRICULUM, WorkBookType.SOLUTION] } },
+    include: { placement: true },
+    orderBy: { id: 'asc' },
+  });
+}
+
+/**
+ * Returns all placements for workbooks of the given type, ordered by priority.
+ */
+export async function getPlacementsByWorkBookType(
+  workBookType: typeof WorkBookType.CURRICULUM | typeof WorkBookType.SOLUTION,
+): Promise<WorkBookPlacements> {
+  return prisma.workBookPlacement.findMany({
+    where: { workBook: { workBookType } },
+    orderBy: { priority: 'asc' },
+  });
+}
+
+/**
+ * Updates existing placements in a single transaction.
+ * No-op when given an empty array.
+ *
+ * Intentional N+1: one UPDATE per row. Acceptable for an infrequent admin-only
+ * operation; raw SQL bulk updates are not worth the type-safety trade-off here.
+ */
+export async function updateWorkBookPlacements(updatedPlacements: PlacementInputs): Promise<void> {
+  if (updatedPlacements.length === 0) {
+    return;
+  }
+
+  await prisma.$transaction(
+    updatedPlacements.map((updatedPlacement) =>
+      prisma.workBookPlacement.update({
+        where: { id: updatedPlacement.id },
+        data: {
+          priority: updatedPlacement.priority,
+          taskGrade: updatedPlacement.taskGrade ?? null,
+          solutionCategory: updatedPlacement.solutionCategory ?? null,
+        },
+      }),
+    ),
+  );
+}
+
+/**
+ * Queries all unplaced CURRICULUM and SOLUTION workbooks, computes their initial
+ * placements, and writes them to the database in a single createMany call.
+ * No-op when all workbooks are already placed.
+ */
+export async function createInitialPlacements(): Promise<void> {
+  const { unplacedCurriculum, unplacedSolution } = await fetchUnplacedWorkbooks();
+
+  if (unplacedCurriculum.length === 0 && unplacedSolution.length === 0) {
+    return;
+  }
+
+  const tasksMapByIds = buildTaskMapFromCurriculumRows(unplacedCurriculum);
+  const curriculumWorkbooksForInit = buildCurriculumWorkbooksForInit(unplacedCurriculum);
+
+  const curriculumPlacements = initializeCurriculumPlacements(
+    curriculumWorkbooksForInit,
+    tasksMapByIds,
+  );
+  const solutionPlacements = initializeSolutionPlacements(unplacedSolution);
+
+  await prisma.workBookPlacement.createMany({
+    data: [...curriculumPlacements, ...solutionPlacements],
+    skipDuplicates: true,
+  });
+}
+
+async function fetchUnplacedWorkbooks() {
+  const [unplacedCurriculum, unplacedSolution] = await Promise.all([
+    prisma.workBook.findMany({
+      where: { workBookType: WorkBookType.CURRICULUM, placement: null },
+      include: {
+        workBookTasks: {
+          include: { task: { select: { task_id: true, grade: true } } },
+        },
+      },
+      orderBy: { id: 'asc' },
+    }),
+    prisma.workBook.findMany({
+      where: { workBookType: WorkBookType.SOLUTION, placement: null },
+      orderBy: { id: 'asc' },
+    }),
+  ]);
+
+  return { unplacedCurriculum, unplacedSolution };
+}
+
+/**
+ * Validates that no update crosses CURRICULUM/SOLUTION boundary, then upserts.
+ * Returns { error } on validation failure, null on success.
+ */
+export async function validateAndUpdatePlacements(
+  updates: PlacementInputs,
+): Promise<{ error: string } | null> {
+  const validationError = await validatePlacements(updates);
+
+  if (validationError) {
+    return validationError;
+  }
+
+  await updateWorkBookPlacements(updates);
+
+  return null;
+}
+
+async function validatePlacements(updates: PlacementInputs): Promise<{ error: string } | null> {
+  const ids = updates.map((update) => update.id);
+  const existingPlacements = await prisma.workBookPlacement.findMany({
+    where: { id: { in: ids } },
+    include: { workBook: { select: { workBookType: true } } },
+  });
+
+  const existingById = new Map(existingPlacements.map((placement) => [placement.id, placement]));
+
+  for (const update of updates) {
+    const existing = existingById.get(update.id);
+
+    if (!existing) {
+      return { error: `Not found placement id=${update.id}` };
+    }
+
+    const isCurriculumToSolution =
+      existing.workBook.workBookType === WorkBookType.CURRICULUM &&
+      update.solutionCategory !== null;
+    const isSolutionToCurriculum =
+      existing.workBook.workBookType === WorkBookType.SOLUTION && update.taskGrade !== null;
+
+    if (isCurriculumToSolution || isSolutionToCurriculum) {
+      return { error: 'Moving between CURRICULUM and SOLUTION is not allowed' };
+    }
+  }
+
+  return null;
+}
+
+// --- Only used for seeding initial placements, not exposed to runtime code ---
+
+/**
+ * Persists an array of new placement records to the database.
+ */
+export async function createWorkBookPlacements(placements: PlacementCreates): Promise<void> {
+  if (placements.length === 0) {
+    return;
+  }
+
+  await prisma.workBookPlacement.createMany({ data: placements });
+}
+
+// Re-export for consumers that only need the placement type (e.g. +server.ts upsert).
+export type { WorkBookPlacement };
diff --git a/src/features/workbooks/services/workbook_placements/initializers.test.ts b/src/features/workbooks/services/workbook_placements/initializers.test.ts
new file mode 100644
index 000000000..6e9bf607a
--- /dev/null
+++ b/src/features/workbooks/services/workbook_placements/initializers.test.ts
@@ -0,0 +1,262 @@
+import { describe, test, expect } from 'vitest';
+
+import { TaskGrade } from '$lib/types/task';
+import {
+  SolutionCategory,
+  type UnplacedCurriculumRows,
+} from '$features/workbooks/types/workbook_placement';
+
+import {
+  buildTaskMapFromCurriculumRows,
+  buildCurriculumWorkbooksForInit,
+  initializeCurriculumPlacements,
+  groupWorkbooksByGrade,
+  buildPlacementsFromGroups,
+  initializeSolutionPlacements,
+} from './initializers';
+
+import {
+  tasksMapByIds,
+  curriculumWorkbooksForInit,
+} from '$features/workbooks/fixtures/workbook_placements';
+
+describe('buildTaskMapFromCurriculumRows', () => {
+  test('builds a task_id → Task map from nested workbook rows', () => {
+    const rows: UnplacedCurriculumRows = [
+      {
+        id: 1,
+        workBookTasks: [
+          { task: { task_id: 'math_and_algorithm_a', grade: TaskGrade.Q10 } },
+          { task: { task_id: 'tessoku_book_a', grade: TaskGrade.Q10 } },
+        ],
+      },
+      {
+        id: 2,
+        workBookTasks: [{ task: { task_id: 'tessoku_book_bz', grade: TaskGrade.Q9 } }],
+      },
+    ];
+
+    const result = buildTaskMapFromCurriculumRows(rows);
+
+    expect(result.size).toBe(3);
+    expect(result.get('math_and_algorithm_a')).toMatchObject({
+      task_id: 'math_and_algorithm_a',
+      grade: TaskGrade.Q10,
+    });
+    expect(result.get('tessoku_book_bz')).toMatchObject({
+      task_id: 'tessoku_book_bz',
+      grade: TaskGrade.Q9,
+    });
+  });
+
+  test('skips workbook tasks where task is null', () => {
+    const rows: UnplacedCurriculumRows = [{ id: 1, workBookTasks: [{ task: null }] }];
+
+    expect(buildTaskMapFromCurriculumRows(rows).size).toBe(0);
+  });
+
+  test('returns empty map for empty input', () => {
+    expect(buildTaskMapFromCurriculumRows([])).toEqual(new Map());
+  });
+});
+
+describe('buildCurriculumWorkbooksForInit', () => {
+  test('converts DB rows to WorkBooksWithTasks shape', () => {
+    const rows: UnplacedCurriculumRows = [
+      {
+        id: 1,
+        workBookTasks: [
+          { task: { task_id: 'math_and_algorithm_a', grade: TaskGrade.Q10 } },
+          { task: { task_id: 'tessoku_book_a', grade: TaskGrade.Q10 } },
+        ],
+      },
+    ];
+
+    const result = buildCurriculumWorkbooksForInit(rows);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      id: 1,
+      workBookTasks: [
+        { taskId: 'math_and_algorithm_a', priority: 0, comment: '' },
+        { taskId: 'tessoku_book_a', priority: 0, comment: '' },
+      ],
+    });
+  });
+
+  test('maps null task to empty string taskId', () => {
+    const rows: UnplacedCurriculumRows = [{ id: 1, workBookTasks: [{ task: null }] }];
+    const result = buildCurriculumWorkbooksForInit(rows);
+
+    expect(result[0].workBookTasks[0]).toEqual({ taskId: '', priority: 0, comment: '' });
+  });
+
+  test('returns empty array for empty input', () => {
+    expect(buildCurriculumWorkbooksForInit([])).toEqual([]);
+  });
+});
+
+describe('initializeCurriculumPlacements', () => {
+  test('assigns mode grade and ascending priority within the same grade by workbook id', () => {
+    // workBook 1: math_and_algorithm_a (Q10), tessoku_book_a (Q10) → mode Q10, priority 1
+    // workBook 2: tessoku_book_bz (Q9), abc169_a (Q9) → mode Q9, priority 1
+    // workBook 7: abc219_a (Q10) → mode Q10, priority 2 (same grade as 1, id > 1)
+    const workbooks = curriculumWorkbooksForInit.filter((workbook) =>
+      [1, 2, 7].includes(workbook.id),
+    );
+
+    const result = initializeCurriculumPlacements(workbooks, tasksMapByIds);
+    const byId = new Map(result.map((placement) => [placement.workBookId, placement]));
+
+    expect(byId.get(1)).toMatchObject({ taskGrade: TaskGrade.Q10, priority: 1 });
+    expect(byId.get(2)).toMatchObject({ taskGrade: TaskGrade.Q9, priority: 1 });
+    expect(byId.get(7)).toMatchObject({ taskGrade: TaskGrade.Q10, priority: 2 });
+  });
+
+  test('assigns PENDING to a workbook with no tasks', () => {
+    const workbooks = [{ id: 1, workBookTasks: [] }];
+    const result = initializeCurriculumPlacements(workbooks, new Map());
+    expect(result[0]).toMatchObject({ workBookId: 1, taskGrade: TaskGrade.PENDING, priority: 1 });
+  });
+
+  test('returns empty array for empty input', () => {
+    expect(initializeCurriculumPlacements([], new Map())).toEqual([]);
+  });
+
+  test('assigns correct grades and priorities for fixture-based task data', () => {
+    // Reflects actual curriculum workbooks from fixtures/workbooks.ts:
+    //   workBook 1: 標準入出力（1 個の整数）→ tasks Q10: math_and_algorithm_a, tessoku_book_a
+    //   workBook 2: 標準入出力（2 個以上の整数）→ tasks Q9: tessoku_book_bz, abc169_a
+    //   workBook 6: if 文 ① → tasks Q8: abc174_a
+    const workbooks = curriculumWorkbooksForInit.filter((workbook) =>
+      [1, 2, 6].includes(workbook.id),
+    );
+
+    const result = initializeCurriculumPlacements(workbooks, tasksMapByIds);
+    const byId = new Map(result.map((placement) => [placement.workBookId, placement]));
+
+    expect(byId.get(1)).toMatchObject({
+      taskGrade: TaskGrade.Q10,
+      solutionCategory: null,
+      priority: 1,
+    });
+    expect(byId.get(2)).toMatchObject({
+      taskGrade: TaskGrade.Q9,
+      solutionCategory: null,
+      priority: 1,
+    });
+    expect(byId.get(6)).toMatchObject({
+      taskGrade: TaskGrade.Q8,
+      solutionCategory: null,
+      priority: 1,
+    });
+  });
+
+  test('assigns ascending priorities within the same grade based on workbook id', () => {
+    // Two Q10 workbooks: id=1 ('標準入出力 1個') and id=7 ('if 文 ②')
+    // id=1 should get priority:1, id=7 should get priority:2
+    const workbooks = curriculumWorkbooksForInit.filter((workbook) => [1, 7].includes(workbook.id));
+
+    const result = initializeCurriculumPlacements(workbooks, tasksMapByIds);
+    const byId = new Map(result.map((placement) => [placement.workBookId, placement]));
+
+    expect(byId.get(1)).toMatchObject({ taskGrade: TaskGrade.Q10, priority: 1 });
+    expect(byId.get(7)).toMatchObject({ taskGrade: TaskGrade.Q10, priority: 2 });
+  });
+});
+
+describe('groupWorkbooksByGrade', () => {
+  test('groups workbooks by mode grade and sorts IDs ascending within each group', () => {
+    const workbooks = [
+      { id: 1, workBookTasks: [] },
+      { id: 2, workBookTasks: [] },
+      { id: 6, workBookTasks: [] },
+    ];
+    const gradeModes = new Map([
+      [1, TaskGrade.Q10],
+      [2, TaskGrade.Q9],
+      [6, TaskGrade.Q10],
+    ]);
+
+    const result = groupWorkbooksByGrade(workbooks, gradeModes);
+
+    expect(result.get(TaskGrade.Q10)).toEqual([1, 6]);
+    expect(result.get(TaskGrade.Q9)).toEqual([2]);
+  });
+
+  test('returns empty map for empty input', () => {
+    expect(groupWorkbooksByGrade([], new Map()).size).toBe(0);
+  });
+});
+
+describe('buildPlacementsFromGroups', () => {
+  test('assigns priority based on ID order within each grade group', () => {
+    const workbooks = [
+      { id: 1, workBookTasks: [] },
+      { id: 2, workBookTasks: [] },
+      { id: 6, workBookTasks: [] },
+    ];
+    const gradeModes = new Map([
+      [1, TaskGrade.Q10],
+      [2, TaskGrade.Q9],
+      [6, TaskGrade.Q10],
+    ]);
+    const byGrade = new Map([
+      [TaskGrade.Q10, [1, 6]],
+      [TaskGrade.Q9, [2]],
+    ]);
+
+    const result = buildPlacementsFromGroups(workbooks, gradeModes, byGrade);
+    const byId = new Map(result.map((placement) => [placement.workBookId, placement]));
+
+    expect(byId.get(1)).toMatchObject({ taskGrade: TaskGrade.Q10, priority: 1 });
+    expect(byId.get(6)).toMatchObject({ taskGrade: TaskGrade.Q10, priority: 2 });
+    expect(byId.get(2)).toMatchObject({ taskGrade: TaskGrade.Q9, priority: 1 });
+  });
+
+  test('sets solutionCategory to null for all records', () => {
+    const workbooks = [{ id: 1, workBookTasks: [] }];
+    const gradeModes = new Map([[1, TaskGrade.Q10]]);
+    const byGrade = new Map([[TaskGrade.Q10, [1]]]);
+
+    const result = buildPlacementsFromGroups(workbooks, gradeModes, byGrade);
+
+    expect(result[0].solutionCategory).toBeNull();
+  });
+});
+
+describe('initializeSolutionPlacements', () => {
+  test('initializes all workbooks with PENDING and sequential priority', () => {
+    const workbooks = [{ id: 31 }, { id: 33 }];
+    const result = initializeSolutionPlacements(workbooks);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({
+      workBookId: 31,
+      solutionCategory: SolutionCategory.PENDING,
+      taskGrade: null,
+      priority: 1,
+    });
+    expect(result[1]).toMatchObject({
+      workBookId: 33,
+      solutionCategory: SolutionCategory.PENDING,
+      taskGrade: null,
+      priority: 2,
+    });
+  });
+
+  test('returns empty array for empty input', () => {
+    expect(initializeSolutionPlacements([])).toEqual([]);
+  });
+
+  test('assigns sequential priorities regardless of workbook id order', () => {
+    // Workbooks may arrive from DB in non-sequential ID order
+    const workbooks = [{ id: 40 }, { id: 31 }, { id: 33 }];
+    const result = initializeSolutionPlacements(workbooks);
+
+    expect(result[0]).toMatchObject({ workBookId: 40, priority: 1 });
+    expect(result[1]).toMatchObject({ workBookId: 31, priority: 2 });
+    expect(result[2]).toMatchObject({ workBookId: 33, priority: 3 });
+    expect(result.every((placement) => placement.taskGrade === null)).toBe(true);
+  });
+});
diff --git a/src/features/workbooks/services/workbook_placements/initializers.ts b/src/features/workbooks/services/workbook_placements/initializers.ts
new file mode 100644
index 000000000..f296522c4
--- /dev/null
+++ b/src/features/workbooks/services/workbook_placements/initializers.ts
@@ -0,0 +1,111 @@
+import { type Task, type TaskGrade } from '$lib/types/task';
+import {
+  SolutionCategory,
+  type WorkBooksWithTasks,
+  type PlacementCreates,
+  type UnplacedCurriculumRows,
+} from '$features/workbooks/types/workbook_placement';
+
+import { calcWorkBookGradeModes } from '$features/workbooks/utils/workbooks';
+
+// --- Curriculum-specific initialization ---
+
+/**
+ * Builds a task lookup map from unplaced curriculum workbook rows.
+ * Stub tasks include only task_id and grade; other fields are left empty.
+ */
+export function buildTaskMapFromCurriculumRows(
+  workbooks: UnplacedCurriculumRows,
+): Map<string, Task> {
+  return new Map(
+    workbooks
+      .flatMap((workbook) => workbook.workBookTasks)
+      .filter((workBookTask) => workBookTask.task !== null)
+      .map((workBookTask) => [
+        workBookTask.task!.task_id,
+        {
+          task_id: workBookTask.task!.task_id,
+          contest_id: '',
+          task_table_index: '',
+          title: '',
+          grade: workBookTask.task!.grade,
+        },
+      ]),
+  );
+}
+
+/**
+ * Converts unplaced curriculum DB rows into the shape expected by initializeCurriculumPlacements.
+ */
+export function buildCurriculumWorkbooksForInit(
+  workbooks: UnplacedCurriculumRows,
+): WorkBooksWithTasks {
+  return workbooks.map((workbook) => ({
+    id: workbook.id,
+    workBookTasks: workbook.workBookTasks.map((workBookTask) => ({
+      taskId: workBookTask.task?.task_id ?? '',
+      priority: 0,
+      comment: '',
+    })),
+  }));
+}
+
+/**
+ * Returns initial placement records for unplaced CURRICULUM workbooks.
+ * Each workbook is assigned the mode grade of its tasks, with priority
+ * determined by ascending workbook ID within each grade group.
+ */
+export function initializeCurriculumPlacements(
+  workbooks: WorkBooksWithTasks,
+  tasksMapByIds: Map<string, Task>,
+): PlacementCreates {
+  const gradeModes = calcWorkBookGradeModes(workbooks, tasksMapByIds);
+  const byGrade = groupWorkbooksByGrade(workbooks, gradeModes);
+  return buildPlacementsFromGroups(workbooks, gradeModes, byGrade);
+}
+
+/**
+ * Groups workbooks by their mode grade, sorted by workbook ID ascending within each group.
+ */
+export function groupWorkbooksByGrade(
+  workbooks: WorkBooksWithTasks,
+  gradeModes: Map<number, TaskGrade>,
+): Map<TaskGrade, number[]> {
+  return workbooks.reduce((byGrade, workbook) => {
+    const grade = gradeModes.get(workbook.id)!;
+    const ids = [...(byGrade.get(grade) ?? []), workbook.id].sort((a, b) => a - b);
+    return byGrade.set(grade, ids);
+  }, new Map<TaskGrade, number[]>());
+}
+
+/**
+ * Builds PlacementCreate records from pre-grouped grade data.
+ * Priority is the 1-based index within each grade group (sorted by workbook ID).
+ */
+export function buildPlacementsFromGroups(
+  workbooks: WorkBooksWithTasks,
+  gradeModes: Map<number, TaskGrade>,
+  byGrade: Map<TaskGrade, number[]>,
+): PlacementCreates {
+  return workbooks.map((workbook) => {
+    const grade = gradeModes.get(workbook.id)!;
+    const ids = byGrade.get(grade)!;
+    const priority = ids.indexOf(workbook.id) + 1;
+    return { workBookId: workbook.id, taskGrade: grade, solutionCategory: null, priority };
+  });
+}
+
+// --- Solution-specific initialization ---
+
+/**
+ * Returns initial placement records for unplaced SOLUTION workbooks.
+ * All are placed in the PENDING category with sequential priority.
+ */
+export function initializeSolutionPlacements(workbooks: { id: number }[]): PlacementCreates {
+  return workbooks.map((workBook, i) => ({
+    workBookId: workBook.id,
+    taskGrade: null,
+    solutionCategory: SolutionCategory.PENDING,
+    priority: i + 1,
+  }));
+}
diff --git a/src/features/workbooks/services/workbook_tasks.ts b/src/features/workbooks/services/workbook_tasks.ts
index 3b209aa6a..d4dcbcfbe 100644
--- a/src/features/workbooks/services/workbook_tasks.ts
+++ b/src/features/workbooks/services/workbook_tasks.ts
@@ -1,21 +1,11 @@
-import type {
-  WorkBook,
-  WorkBookTaskBase,
-  WorkBookTasksBase,
-} from '$features/workbooks/types/workbook';
+import type { WorkBook, WorkBookTasksBase } from '$features/workbooks/types/workbook';
 
-export async function getWorkBookTasks(workBook: Omit<WorkBook, 'id'>): Promise<WorkBookTasksBase> {
-  const workBookTasks: WorkBookTasksBase = await Promise.all(
-    workBook.workBookTasks.map(async (workBookTask: WorkBookTaskBase) => {
-      return {
-        taskId: workBookTask.taskId,
-        priority: workBookTask.priority,
-        comment: workBookTask.comment,
-      };
-    }),
-  );
-
-  return workBookTasks;
+export function getWorkBookTasks(workBook: Omit<WorkBook, 'id'>): WorkBookTasksBase {
+  return workBook.workBookTasks.map((workBookTask) => ({
+    taskId: workBookTask.taskId,
+    priority: workBookTask.priority,
+    comment: workBookTask.comment,
+  }));
 }
 
 export function validateRequiredFields(workBookTasks: WorkBookTasksBase): void {
diff --git a/src/features/workbooks/services/workbooks.ts b/src/features/workbooks/services/workbooks.ts
index f6e69e45e..d24aacccf 100644
--- a/src/features/workbooks/services/workbooks.ts
+++ b/src/features/workbooks/services/workbooks.ts
@@ -115,7 +115,7 @@ export async function createWorkBook(workBook: Omit<WorkBook, 'id'>): Promise<vo
   }
 
   const sanitizedUrl = sanitizeUrl(workBook.editorialUrl);
-  const newWorkBookTasks: WorkBookTasksBase = await getWorkBookTasks(workBook);
+  const newWorkBookTasks: WorkBookTasksBase = getWorkBookTasks(workBook);
 
   const newWorkBook = await db.workBook.create({
     data: {
@@ -159,7 +159,7 @@ export async function updateWorkBook(workBookId: number, workBook: WorkBook): Pr
     throw new Error(`Not found WorkBook with id ${workBookId}.`);
   }
 
-  const newWorkBookTasks: WorkBookTasksBase = await getWorkBookTasks(workBook);
+  const newWorkBookTasks: WorkBookTasksBase = getWorkBookTasks(workBook);
 
   validateRequiredFields(newWorkBookTasks);
 
@@ -179,8 +179,6 @@ export async function updateWorkBook(workBookId: number, workBook: WorkBook): Pr
         },
       }),
     ]);
-
-    console.log(await getWorkBook(workBookId));
   } catch (error) {
     console.error(
       `Failed to update WorkBook with id ${workBookId} and title ${workBook.title}:`,
diff --git a/src/features/workbooks/types/workbook_placement.ts b/src/features/workbooks/types/workbook_placement.ts
new file mode 100644
index 000000000..51753d986
--- /dev/null
+++ b/src/features/workbooks/types/workbook_placement.ts
@@ -0,0 +1,99 @@
+import type { SolutionCategory as SolutionCategoryOrigin } from '@prisma/client';
+import type { TaskGrade } from '$lib/types/task';
+import type { WorkBookTaskBase } from '$features/workbooks/types/workbook';
+
+// Categories for solution placement.
+export const SolutionCategory: { [key in SolutionCategoryOrigin]: key } = {
+  PENDING: 'PENDING',
+  SEARCH_SIMULATION: 'SEARCH_SIMULATION',
+  DYNAMIC_PROGRAMMING: 'DYNAMIC_PROGRAMMING',
+  DATA_STRUCTURE: 'DATA_STRUCTURE',
+  GRAPH: 'GRAPH',
+  TREE: 'TREE',
+  NUMBER_THEORY: 'NUMBER_THEORY',
+  ALGEBRA: 'ALGEBRA',
+  COMBINATORICS: 'COMBINATORICS',
+  GAME: 'GAME',
+  STRING: 'STRING',
+  GEOMETRY: 'GEOMETRY',
+  OPTIMIZATION: 'OPTIMIZATION',
+  OTHERS: 'OTHERS',
+  ANALYSIS: 'ANALYSIS',
+} as const;
+
+export type SolutionCategory = SolutionCategoryOrigin;
+
+// Japanese labels for solution categories (used in admin UI)
+export const SOLUTION_LABELS: Record<string, string> = {
+  PENDING: '未分類',
+  SEARCH_SIMULATION: '探索・シミュレーション・実装',
+  DYNAMIC_PROGRAMMING: '動的計画法',
+  DATA_STRUCTURE: 'データ構造',
+  GRAPH: 'グラフ',
+  TREE: '木',
+  NUMBER_THEORY: '数学（整数論）',
+  ALGEBRA: '数学（代数）',
+  COMBINATORICS: '数え上げ・確率・期待値',
+  GAME: 'ゲーム',
+  STRING: '文字列',
+  GEOMETRY: '幾何',
+  OPTIMIZATION: '最適化',
+  OTHERS: 'その他',
+  ANALYSIS: '考察テクニック',
+};
+
+// Admin only: Used for ordering of workbooks (curriculums and solution)
+export type WorkBookPlacement = {
+  id: number;
+  workBookId: number;
+  taskGrade: TaskGrade | null;
+  solutionCategory: SolutionCategory | null;
+  priority: number;
+};
+
+export type WorkBookPlacements = WorkBookPlacement[];
+
+// Input type for updating placements (id + fields to update)
+export type PlacementInput = Pick<
+  WorkBookPlacement,
+  'id' | 'taskGrade' | 'solutionCategory' | 'priority'
+>;
+
+export type PlacementInputs = PlacementInput[];
+
+// Shape of a placement record to be created in the database
+export type PlacementCreate = {
+  workBookId: number;
+  taskGrade: TaskGrade | null;
+  solutionCategory: SolutionCategory | null;
+  priority: number;
+};
+
+export type PlacementCreates = PlacementCreate[];
+
+// Workbook shape required by initializeCurriculumPlacements
+export type WorkBookWithTasks = {
+  id: number;
+  workBookTasks: WorkBookTaskBase[];
+};
+
+export type WorkBooksWithTasks = WorkBookWithTasks[];
+
+// Shape of a curriculum workbook row queried for placement initialization
+export type UnplacedCurriculumRow = {
+  id: number;
+  workBookTasks: { task: { task_id: string; grade: TaskGrade } | null }[];
+};
+
+export type UnplacedCurriculumRows = UnplacedCurriculumRow[];
+
+// Shape of workbooks returned from the load function for use in KanbanBoard
+export type WorkbookWithPlacement = {
+  id: number;
+  title: string;
+  isPublished: boolean;
+  workBookType: string;
+  placement: WorkBookPlacement | null;
+};
+
+export type WorkbooksWithPlacement = WorkbookWithPlacement[];
diff --git a/src/features/workbooks/utils/workbook_tasks.ts b/src/features/workbooks/utils/workbook_tasks.ts
index 19250d96c..4f9ccba1f 100644
--- a/src/features/workbooks/utils/workbook_tasks.ts
+++ b/src/features/workbooks/utils/workbook_tasks.ts
@@ -8,7 +8,7 @@ import type {
   WorkBookTasksEdit,
 } from '$features/workbooks/types/workbook';
 
-// Note: アプリの表示上、内部処理とも0-indexed
+// Note: 0-indexed for both display and internal use
 export function generateWorkBookTaskOrders(workBookTaskCount: number) {
   return Array.from({ length: workBookTaskCount + 1 }, (_, index) => ({
     name: index,
@@ -18,7 +18,7 @@ export function generateWorkBookTaskOrders(workBookTaskCount: number) {
 
 export const PENDING = -1;
 
-// Note: 初期値として、便宜的に割り当てている。随時、変更可能。
+// Note: Convenience default value; can be changed at any time.
 export const NO_COMMENT = '';
 
 export function addTaskToWorkBook(
@@ -27,14 +27,14 @@ export function addTaskToWorkBook(
   workBookTasksForTable: WorkBookTasksCreate | WorkBookTasksEdit,
   newWorkBookTaskIndex: number,
 ) {
-  // データベース用
+  // For database
   const updatedWorkBookTasks = updateWorkBookTasks(
     workBookTasks,
     newWorkBookTaskIndex,
     selectedTask,
   );
 
-  // アプリの表示用
+  // For display
   const updatedWorkBookTasksForTable: WorkBookTasksCreate | WorkBookTasksEdit =
     updateWorkBookTaskForTable(workBookTasksForTable, newWorkBookTaskIndex, selectedTask);
 
@@ -48,7 +48,7 @@ export function updateWorkBookTasks(
 ): WorkBookTasksBase {
   const newWorkBookTask: WorkBookTaskBase = {
     taskId: selectedTask.task_id,
-    priority: PENDING, // 1に近いほど優先度が高い
+    priority: PENDING, // Lower value = higher priority
     comment: NO_COMMENT,
   };
   let updatedWorkBookTasks: WorkBookTasksBase = insertTaskToWorkBook(
@@ -73,7 +73,7 @@ export function updateWorkBookTaskForTable(
     priority: PENDING,
     comment: NO_COMMENT,
   };
-  // HACK: オーバーロードを定義しているにもかかわらず戻り値の型がWorkBookTasksBaseになってしまうため、やむを得ずキャスト
+  // HACK: Cast required despite overloads - TypeScript infers WorkBookTasksBase as the return type
   let updatedWorkBookTasksForTable: WorkBookTasksCreate | WorkBookTasksEdit = insertTaskToWorkBook(
     workBookTasksForTable,
     selectedIndex,
@@ -86,7 +86,7 @@ export function updateWorkBookTaskForTable(
   return updatedWorkBookTasksForTable;
 }
 
-// 関数のオーバーロードを定義
+// Function overloads
 function insertTaskToWorkBook(
   workBookTasks: WorkBookTasksBase,
   selectedIndex: number,
@@ -107,9 +107,7 @@ function insertTaskToWorkBook(
   selectedIndex: number,
   newWorkBookTask: WorkBookTaskBase | WorkBookTaskCreate | WorkBookTaskEdit,
 ): WorkBookTasksBase | WorkBookTasksCreate | WorkBookTasksEdit {
-  // 範囲外のインデックスを指定された場合の仕様
-  // 負の値: 先頭に追加
-  // 元の配列よりも大きな値: 末尾に追加
+  // Out-of-bounds behavior: negative index → prepend; index > length → append
   if (selectedIndex < 0) {
     selectedIndex = 0;
   } else if (selectedIndex > workBookTasks.length) {
diff --git a/src/features/workbooks/utils/workbooks.test.ts b/src/features/workbooks/utils/workbooks.test.ts
index bac75ff51..644427aee 100644
--- a/src/features/workbooks/utils/workbooks.test.ts
+++ b/src/features/workbooks/utils/workbooks.test.ts
@@ -1,9 +1,25 @@
 import { expect, test } from 'vitest';
 
-import { canViewWorkBook, getUrlSlugFrom } from '$features/workbooks/utils/workbooks';
 import { Roles } from '$lib/types/user';
+import { TaskGrade, type Task } from '$lib/types/task';
 import { type WorkbookList, WorkBookType } from '$features/workbooks/types/workbook';
 
+import {
+  canViewWorkBook,
+  getUrlSlugFrom,
+  calcWorkBookGradeModes,
+} from '$features/workbooks/utils/workbooks';
+
+function createTask(taskId: string, grade: TaskGrade): Task {
+  return {
+    task_id: taskId,
+    contest_id: '',
+    task_table_index: '',
+    title: '',
+    grade,
+  };
+}
+
 function createWorkBookListBase(overrides: Partial<WorkbookList> = {}): WorkbookList {
   return {
     id: 1,
@@ -66,4 +82,96 @@ describe('Workbooks', () => {
       expect(getUrlSlugFrom(workbook)).toBe('999');
     });
   });
+
+  describe('calcWorkBookGradeModes', () => {
+    test('returns most frequent grade for each workbook', () => {
+      const tasksMapByIds: Map<string, Task> = new Map([
+        ['abc322_d', createTask('abc322_d', TaskGrade.Q1)],
+        ['abc347_c', createTask('abc347_c', TaskGrade.Q1)],
+        ['abc307_c', createTask('abc307_c', TaskGrade.Q2)],
+      ]);
+      const workbooks = [
+        createWorkBookListBase({
+          id: 1,
+          workBookTasks: [
+            { taskId: 'abc322_d', priority: 1, comment: '' },
+            { taskId: 'abc347_c', priority: 2, comment: '' },
+            { taskId: 'abc307_c', priority: 3, comment: '' },
+          ],
+        }),
+      ];
+      const result = calcWorkBookGradeModes(workbooks, tasksMapByIds);
+      expect(result.get(1)).toBe(TaskGrade.Q1);
+    });
+
+    test('returns PENDING for workbook without tasks', () => {
+      const tasksMapByIds: Map<string, Task> = new Map();
+      const workbooks = [createWorkBookListBase({ id: 1, workBookTasks: [] })];
+      const result = calcWorkBookGradeModes(workbooks, tasksMapByIds);
+      expect(result.get(1)).toBe(TaskGrade.PENDING);
+    });
+
+    test('returns PENDING for workbook with all PENDING tasks', () => {
+      const tasksMapByIds: Map<string, Task> = new Map([
+        ['abc322_d', createTask('abc322_d', TaskGrade.PENDING)],
+        ['abc347_c', createTask('abc347_c', TaskGrade.PENDING)],
+        ['abc307_c', createTask('abc307_c', TaskGrade.PENDING)],
+      ]);
+      const workbooks = [
+        createWorkBookListBase({
+          id: 1,
+          workBookTasks: [
+            { taskId: 'abc322_d', priority: 1, comment: '' },
+            { taskId: 'abc347_c', priority: 2, comment: '' },
+            { taskId: 'abc307_c', priority: 3, comment: '' },
+          ],
+        }),
+      ];
+      const result = calcWorkBookGradeModes(workbooks, tasksMapByIds);
+      expect(result.get(1)).toBe(TaskGrade.PENDING);
+    });
+
+    test('returns empty map for empty workbooks array', () => {
+      const tasksMapByIds: Map<string, Task> = new Map();
+      const result = calcWorkBookGradeModes([], tasksMapByIds);
+      expect(result.size).toBe(0);
+    });
+
+    test('ignores tasks not found in tasksMapByIds', () => {
+      const tasksMapByIds: Map<string, Task> = new Map([
+        ['abc322_d', createTask('abc322_d', TaskGrade.Q9)],
+      ]);
+      const workbooks = [
+        createWorkBookListBase({
+          id: 1,
+          workBookTasks: [
+            { taskId: 'abc322_d', priority: 1, comment: '' },
+            { taskId: 'missing', priority: 2, comment: '' },
+          ],
+        }),
+      ];
+      const result = calcWorkBookGradeModes(workbooks, tasksMapByIds);
+      expect(result.get(1)).toBe(TaskGrade.Q9);
+    });
+
+    test('handles multiple workbooks independently', () => {
+      const tasksMapByIds: Map<string, Task> = new Map([
+        ['abc440_a', createTask('abc440_a', TaskGrade.Q8)],
+        ['abc425_a', createTask('abc425_a', TaskGrade.Q7)],
+      ]);
+      const workbooks = [
+        createWorkBookListBase({
+          id: 10,
+          workBookTasks: [{ taskId: 'abc440_a', priority: 1, comment: '' }],
+        }),
+        createWorkBookListBase({
+          id: 20,
+          workBookTasks: [{ taskId: 'abc425_a', priority: 1, comment: '' }],
+        }),
+      ];
+      const result = calcWorkBookGradeModes(workbooks, tasksMapByIds);
+      expect(result.get(10)).toBe(TaskGrade.Q8);
+      expect(result.get(20)).toBe(TaskGrade.Q7);
+    });
+  });
 });
diff --git a/src/features/workbooks/utils/workbooks.ts b/src/features/workbooks/utils/workbooks.ts
index b816e7fa8..e314016cf 100644
--- a/src/features/workbooks/utils/workbooks.ts
+++ b/src/features/workbooks/utils/workbooks.ts
@@ -1,7 +1,9 @@
 import { Roles } from '$lib/types/user';
-import type { WorkBook, WorkbookList } from '$features/workbooks/types/workbook';
+import { TaskGrade, type Task, type TaskGrades } from '$lib/types/task';
+import type { WorkBook, WorkbookList, WorkBookTaskBase } from '$features/workbooks/types/workbook';
 
 import { isAdmin } from '$lib/utils/authorship';
+import { calcGradeMode } from '$lib/utils/task';
 
 // 管理者 + ユーザ向けに公開されている場合
 export function canViewWorkBook(role: Roles, isPublished: boolean) {
@@ -19,3 +21,38 @@ export function getUrlSlugFrom(workbook: WorkbookList | WorkBook): string {
 
   return slug ? slug : workbook.id.toString();
 }
+
+/**
+ * Calculates the grade modes for a list of workbooks in curriculum based on their tasks.
+ *
+ * @param workbooks - Workbooks with their task lists (only `id` and `workBookTasks` are used)
+ * @param tasksMapByIds - A map of task IDs to task objects
+ *
+ * @returns A map of workbook IDs to their corresponding grade modes
+ * @note The time complexity is O(N * M * log(M)), where N is the number of workbooks and M is the average number of tasks per workbook.
+ */
+export function calcWorkBookGradeModes(
+  workbooks: { id: number; workBookTasks: WorkBookTaskBase[] }[],
+  tasksMapByIds: Map<string, Task>,
+): Map<number, TaskGrade> {
+  const gradeModes: Map<number, TaskGrade> = new Map();
+
+  workbooks.forEach((workbook: { id: number; workBookTasks: WorkBookTaskBase[] }) => {
+    const taskGrades = workbook.workBookTasks.reduce(
+      (results: TaskGrades, workBookTask: WorkBookTaskBase) => {
+        const task = tasksMapByIds.get(workBookTask.taskId);
+
+        if (task && task.grade !== TaskGrade.PENDING) {
+          results.push(task.grade as TaskGrade);
+        }
+
+        return results;
+      },
+      [],
+    );
+
+    gradeModes.set(workbook.id, calcGradeMode(taskGrades));
+  });
+
+  return gradeModes;
+}
diff --git a/src/features/workbooks/zod/schema.test.ts b/src/features/workbooks/zod/schema.test.ts
index 4cc86dae7..a2e8d6e16 100644
--- a/src/features/workbooks/zod/schema.test.ts
+++ b/src/features/workbooks/zod/schema.test.ts
@@ -1,8 +1,11 @@
 import { expect, test } from 'vitest';
 import { type ZodSchema } from 'zod';
 
-import { workBookSchema } from '$features/workbooks/zod/schema';
+import { TaskGrade } from '$lib/types/task';
 import { WorkBookType, type WorkBookTasks } from '$features/workbooks/types/workbook';
+import { SolutionCategory } from '$features/workbooks/types/workbook_placement';
+
+import { workBookSchema, workBookPlacementSchema } from '$features/workbooks/zod/schema';
 
 type WorkBook = {
   authorId: string;
@@ -453,7 +456,7 @@ describe('workbook schema', () => {
     function validateWorkBookSchema(schema: ZodSchema<unknown>, workbook: WorkBook) {
       const result = schema.safeParse(workbook);
 
-      expect(result.success).toBeFalsy();
+      expect(result.success).toBe(false);
     }
   });
 
@@ -468,3 +471,109 @@ describe('workbook schema', () => {
     return 'abc' + randomNumber + '_' + letters[randomIndex];
   }
 });
+
+describe('workBookPlacementSchema', () => {
+  describe('a correct workbook placement is given', () => {
+    test('only taskGrade is non-null (CURRICULUM)', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 1,
+        taskGrade: TaskGrade.Q10,
+        solutionCategory: null,
+      });
+      expect(result.success).toBe(true);
+    });
+
+    test('only solutionCategory is non-null (SOLUTION)', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 1,
+        taskGrade: null,
+        solutionCategory: SolutionCategory.GRAPH,
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('an incorrect workbook placement is given', () => {
+    test('both null', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 1,
+        taskGrade: null,
+        solutionCategory: null,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    test('both non-null', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 1,
+        taskGrade: TaskGrade.Q10,
+        solutionCategory: SolutionCategory.GRAPH,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    test('invalid taskGrade', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 1,
+        taskGrade: 'INVALID' as TaskGrade,
+        solutionCategory: null,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    test('invalid solutionCategory', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 1,
+        taskGrade: null,
+        solutionCategory: 'INVALID' as SolutionCategory,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    test('priority of 0', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 0,
+        taskGrade: TaskGrade.Q10,
+        solutionCategory: null,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    test('negative priority', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: -1,
+        taskGrade: null,
+        solutionCategory: SolutionCategory.GRAPH,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    test('fractional priority is rejected', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1,
+        priority: 1.5,
+        taskGrade: TaskGrade.Q10,
+        solutionCategory: null,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    test('fractional id is rejected', () => {
+      const result = workBookPlacementSchema.safeParse({
+        id: 1.5,
+        priority: 1,
+        taskGrade: null,
+        solutionCategory: SolutionCategory.GRAPH,
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+});
diff --git a/src/features/workbooks/zod/schema.ts b/src/features/workbooks/zod/schema.ts
index e20d3eb61..12496d35a 100644
--- a/src/features/workbooks/zod/schema.ts
+++ b/src/features/workbooks/zod/schema.ts
@@ -3,7 +3,11 @@
 // https://regex101.com/
 // https://qiita.com/mpyw/items/886218e7b418dfed254b
 import { z } from 'zod';
+
+import { TaskGrade } from '$lib/types/task';
 import { WorkBookType } from '$features/workbooks/types/workbook';
+import { SolutionCategory } from '$features/workbooks/types/workbook_placement';
+
 import { isValidUrl, isValidUrlSlug } from '$lib/utils/url';
 
 const workBookTaskSchema = z.object({
@@ -57,3 +61,23 @@ export const workBookSchema = z.object({
     .min(1, { error: '1問以上登録してください' })
     .max(200, { error: '200問以下になるまで削除してください' }),
 });
+
+export const workBookPlacementSchema = z
+  .object({
+    id: z.number().int().positive(),
+    priority: z.number().int().positive(),
+    taskGrade: z.nativeEnum(TaskGrade).nullable(),
+    solutionCategory: z.nativeEnum(SolutionCategory).nullable(),
+  })
+  // Note: XOR constraint: dual enforcement via Zod (early validation) and a CHECK in migration.sql (last line of defence).
+  // Prisma lacks @@check, so the SQL constraint is maintained manually. Keep both in sync.
+  .refine(
+    (value) =>
+      (value.taskGrade !== null && value.solutionCategory === null) ||
+      (value.taskGrade === null && value.solutionCategory !== null),
+    { error: 'taskGrade と solutionCategory は片方のみ設定できます' },
+  );
+
+export const updatePlacementsSchema = z.object({
+  updates: z.array(workBookPlacementSchema),
+});
diff --git a/src/lib/components/ContainerWrapper.svelte b/src/lib/components/ContainerWrapper.svelte
index 58eef531a..e9eeafd83 100644
--- a/src/lib/components/ContainerWrapper.svelte
+++ b/src/lib/components/ContainerWrapper.svelte
@@ -3,12 +3,13 @@
 
   interface Props {
     defaultWidth?: string;
+    lgWidth?: string;
     children?: Snippet;
   }
 
-  let { defaultWidth = 'w-5/6', children }: Props = $props();
+  let { defaultWidth = 'w-5/6', lgWidth = 'lg:w-3/4', children }: Props = $props();
 </script>
 
-<div class={`container ${defaultWidth} lg:w-3/4 mx-auto flex flex-col items-center`}>
+<div class={`container ${defaultWidth} ${lgWidth} mx-auto flex flex-col items-center`}>
   {@render children?.()}
 </div>
diff --git a/src/lib/constants/http-response-status-codes.ts b/src/lib/constants/http-response-status-codes.ts
index 879ddc52d..6444f42dc 100644
--- a/src/lib/constants/http-response-status-codes.ts
+++ b/src/lib/constants/http-response-status-codes.ts
@@ -1,6 +1,9 @@
 // See:
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
 
+// Successful responses
+export const OK = 200;
+
 // Redirection messages
 export const FOUND = 302;
 export const SEE_OTHER = 303;
diff --git a/src/lib/constants/navbar-links.ts b/src/lib/constants/navbar-links.ts
index efd70cffb..fd8fcf0f4 100644
--- a/src/lib/constants/navbar-links.ts
+++ b/src/lib/constants/navbar-links.ts
@@ -10,6 +10,7 @@ export const PROBLEMS_PAGE = `/problems`;
 export const IMPORTING_PROBLEMS_PAGE = `/tasks`;
 export const TAGS_PAGE = `/tags`;
 export const ACCOUNT_TRANSFER_PAGE = `/account_transfer`;
+export const WORKBOOKS_ORDER_PAGE = `/workbooks/order`;
 
 export const navbarLinks = [
   { title: `ホーム`, path: HOME_PAGE },
@@ -22,6 +23,7 @@ export const navbarDashboardLinks = [
   { title: `問題のインポート`, path: IMPORTING_PROBLEMS_PAGE },
   { title: `一覧表`, path: PROBLEMS_PAGE },
   { title: `問題集`, path: WORKBOOKS_PAGE },
+  { title: `問題集（並び替え）`, path: WORKBOOKS_ORDER_PAGE },
   { title: `タグ一覧`, path: TAGS_PAGE },
   { title: `アカウント移行`, path: ACCOUNT_TRANSFER_PAGE },
 ];
diff --git a/src/routes/(admin)/_utils/auth.ts b/src/routes/(admin)/_utils/auth.ts
new file mode 100644
index 000000000..916262bda
--- /dev/null
+++ b/src/routes/(admin)/_utils/auth.ts
@@ -0,0 +1,62 @@
+import { redirect, error } from '@sveltejs/kit';
+
+import * as userService from '$lib/services/users';
+
+import { Roles } from '$lib/types/user';
+
+import { isAdmin } from '$lib/utils/authorship';
+
+import { LOGIN_PAGE } from '$lib/constants/navbar-links';
+import {
+  TEMPORARY_REDIRECT,
+  UNAUTHORIZED,
+  FORBIDDEN,
+} from '$lib/constants/http-response-status-codes';
+
+enum AdminStatus {
+  OK = 'ok',
+  UNAUTHENTICATED = 'unauthenticated',
+  UNAUTHORIZED = 'unauthorized',
+}
+
+/**
+ * Validates that the current session belongs to an admin user.
+ * Redirects to the login page if the session is missing or the user is not an admin.
+ */
+export async function validateAdminAccess(locals: App.Locals): Promise<void> {
+  if ((await validateAdminStatus(locals)) !== AdminStatus.OK) {
+    redirect(TEMPORARY_REDIRECT, LOGIN_PAGE);
+  }
+}
+
+/**
+ * Validates admin access for API routes (+server.ts).
+ * Throws error(401/403) instead of redirect so fetch() callers receive a proper HTTP status.
+ */
+export async function validateAdminAccessForApi(locals: App.Locals): Promise<void> {
+  const status = await validateAdminStatus(locals);
+
+  if (status === AdminStatus.UNAUTHENTICATED) {
+    error(UNAUTHORIZED);
+  }
+
+  if (status === AdminStatus.UNAUTHORIZED) {
+    error(FORBIDDEN);
+  }
+}
+
+async function validateAdminStatus(locals: App.Locals): Promise<AdminStatus> {
+  const session = await locals.auth.validate();
+
+  if (!session) {
+    return AdminStatus.UNAUTHENTICATED;
+  }
+
+  const user = await userService.getUser(session.user.username);
+
+  if (!user || !isAdmin(user.role as Roles)) {
+    return AdminStatus.UNAUTHORIZED;
+  }
+
+  return AdminStatus.OK;
+}
diff --git a/src/routes/(admin)/workbooks/order/+page.server.ts b/src/routes/(admin)/workbooks/order/+page.server.ts
new file mode 100644
index 000000000..df4010a8a
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/+page.server.ts
@@ -0,0 +1,26 @@
+import { type Actions } from '@sveltejs/kit';
+
+import {
+  getWorkbooksWithPlacements,
+  createInitialPlacements,
+} from '$features/workbooks/services/workbook_placements/crud';
+
+import { validateAdminAccess } from '../../_utils/auth';
+
+export async function load({ locals }) {
+  await validateAdminAccess(locals);
+
+  const workbooks = await getWorkbooksWithPlacements();
+  const hasUnplacedWorkbooks = workbooks.some((workbook) => !workbook.placement);
+
+  return { workbooks, hasUnplacedWorkbooks };
+}
+
+export const actions: Actions = {
+  initializePlacements: async ({ locals }) => {
+    await validateAdminAccess(locals);
+    await createInitialPlacements();
+
+    return { success: true };
+  },
+};
diff --git a/src/routes/(admin)/workbooks/order/+page.svelte b/src/routes/(admin)/workbooks/order/+page.svelte
new file mode 100644
index 000000000..c0f255669
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/+page.svelte
@@ -0,0 +1,28 @@
+<script lang="ts">
+  import type { PageData } from './$types';
+
+  import ContainerWrapper from '$lib/components/ContainerWrapper.svelte';
+  import HeadingOne from '$lib/components/HeadingOne.svelte';
+  import KanbanBoard from './_components/KanbanBoard.svelte';
+
+  let { data }: { data: PageData } = $props();
+</script>
+
+<ContainerWrapper defaultWidth="w-full" lgWidth="lg:w-full">
+  <div class="w-full lg:pl-6">
+    <HeadingOne title="問題集（並び替え）" />
+
+    {#if data.hasUnplacedWorkbooks}
+      <form method="POST" action="?/initializePlacements" class="mb-6">
+        <button
+          type="submit"
+          class="px-4 py-2 bg-primary-600 text-white rounded-lg hover:bg-primary-700 font-medium text-sm"
+        >
+          ボードに問題集を追加
+        </button>
+      </form>
+    {/if}
+
+    <KanbanBoard workbooks={data.workbooks} />
+  </div>
+</ContainerWrapper>
diff --git a/src/routes/(admin)/workbooks/order/+server.ts b/src/routes/(admin)/workbooks/order/+server.ts
new file mode 100644
index 000000000..4e2549d4f
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/+server.ts
@@ -0,0 +1,28 @@
+import { json, type RequestEvent } from '@sveltejs/kit';
+
+import { validateAndUpdatePlacements } from '$features/workbooks/services/workbook_placements/crud';
+
+import { updatePlacementsSchema } from '$features/workbooks/zod/schema';
+
+import { validateAdminAccessForApi } from '../../_utils/auth';
+
+import { BAD_REQUEST } from '$lib/constants/http-response-status-codes';
+
+export async function POST({ request, locals }: RequestEvent) {
+  await validateAdminAccessForApi(locals);
+
+  const body = await request.json();
+  const parsed = updatePlacementsSchema.safeParse(body);
+
+  if (!parsed.success) {
+    return json({ error: 'Invalid request body' }, { status: BAD_REQUEST });
+  }
+
+  const validationError = await validateAndUpdatePlacements(parsed.data.updates);
+
+  if (validationError) {
+    return json(validationError, { status: BAD_REQUEST });
+  }
+
+  return json({ success: true });
+}
diff --git a/src/routes/(admin)/workbooks/order/_components/ColumnSelector.svelte b/src/routes/(admin)/workbooks/order/_components/ColumnSelector.svelte
new file mode 100644
index 000000000..7e11fb38d
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_components/ColumnSelector.svelte
@@ -0,0 +1,44 @@
+<script lang="ts">
+  interface Option {
+    value: string;
+    label: string;
+  }
+
+  interface Props {
+    options: Option[];
+    selected: string[];
+    onchange: (selected: string[]) => void;
+    minRequired?: number;
+  }
+
+  // DnD requires at least 2 panels as movement destinations; fewer would trap all cards in one column
+  let { options, selected, onchange, minRequired = 2 }: Props = $props();
+
+  function toggle(value: string) {
+    const next = selected.includes(value)
+      ? selected.filter((item) => item !== value)
+      : [...selected, value];
+
+    if (next.length < minRequired) {
+      return;
+    }
+
+    onchange(next);
+  }
+</script>
+
+<div class="flex flex-wrap gap-2">
+  {#each options as option}
+    {@const isSelected = selected.includes(option.value)}
+
+    <button
+      type="button"
+      onclick={() => toggle(option.value)}
+      class="px-3 py-1 rounded-full text-sm font-medium border transition-colors {isSelected
+        ? 'bg-primary-600 hover:bg-primary-700 text-white border-primary-600'
+        : 'bg-white hover:bg-gray-50 hover:text-primary-700 dark:bg-gray-700 dark:hover:bg-gray-600 text-gray-700 dark:text-gray-300 border-gray-300 dark:border-gray-600'}"
+    >
+      {option.label}
+    </button>
+  {/each}
+</div>
diff --git a/src/routes/(admin)/workbooks/order/_components/KanbanBoard.svelte b/src/routes/(admin)/workbooks/order/_components/KanbanBoard.svelte
new file mode 100644
index 000000000..1170c10cb
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_components/KanbanBoard.svelte
@@ -0,0 +1,177 @@
+<script lang="ts">
+  import { page } from '$app/stores';
+  import { replaceState } from '$app/navigation';
+  import { untrack } from 'svelte';
+
+  import { Toast } from 'flowbite-svelte';
+  import CircleX from '@lucide/svelte/icons/circle-x';
+
+  import { DragDropProvider } from '@dnd-kit/svelte';
+  import { move } from '@dnd-kit/helpers';
+
+  import {
+    SolutionCategory,
+    type WorkbooksWithPlacement,
+  } from '$features/workbooks/types/workbook_placement';
+  import { TaskGrade } from '$lib/types/task';
+  import type {
+    KanbanColumns,
+    DragOverEventArg,
+    DragEndEventArg,
+    ActiveTab,
+  } from '../_types/kanban';
+
+  import KanbanTabBar from './KanbanTabBar.svelte';
+  import KanbanColumn from './KanbanColumn.svelte';
+
+  import {
+    buildKanbanItems,
+    buildUpdatedUrl,
+    parseInitialCategories,
+    parseInitialGrades,
+    parseTab,
+    reCalcPriorities,
+    saveUpdates,
+    TAB_CONFIGS,
+  } from '../_utils/kanban';
+
+  interface Props {
+    workbooks: WorkbooksWithPlacement;
+  }
+
+  let { workbooks }: Props = $props();
+
+  const { searchParams } = $page.url;
+  let activeTab = $state<ActiveTab>(parseTab(searchParams.get('tab')));
+  let selectedSolutionCategories = $state(parseInitialCategories(searchParams));
+  let selectedGrades = $state(parseInitialGrades(searchParams));
+
+  // PENDING is always shown, so keep it separate from the selectable columns
+  let displayedSolutionCategories = $derived([
+    SolutionCategory.PENDING,
+    ...selectedSolutionCategories.filter((category) => category !== SolutionCategory.PENDING),
+  ]);
+
+  function updateUrl() {
+    replaceState(
+      buildUpdatedUrl($page.url, activeTab, selectedSolutionCategories, selectedGrades),
+      {},
+    );
+  }
+
+  let allItems = $state<Record<string, KanbanColumns>>(
+    untrack(() => ({
+      solution: buildKanbanItems(
+        workbooks,
+        Object.keys(SolutionCategory),
+        (workbook) => workbook.placement?.solutionCategory ?? null,
+      ),
+      curriculum: buildKanbanItems(
+        workbooks,
+        Object.keys(TaskGrade),
+        (workbook) => workbook.placement?.taskGrade ?? null,
+      ),
+    })),
+  );
+
+  let snapshot: KanbanColumns | null = null;
+  let errorMessage = $state<string | null>(null);
+
+  // Drag-and-drop handlers
+  function onDragStart() {
+    snapshot = structuredClone($state.snapshot(allItems[activeTab]));
+  }
+
+  function onDragOver(event: DragOverEventArg) {
+    allItems[activeTab] = move(allItems[activeTab], event);
+  }
+
+  async function onDragEnd(event: DragEndEventArg) {
+    if (!event.operation?.source || !event.operation?.target) {
+      return;
+    }
+
+    const capturedTab = activeTab;
+    const capturedSnapshot = snapshot;
+
+    const updates = reCalcPriorities(
+      capturedSnapshot ?? {},
+      allItems[capturedTab],
+      TAB_CONFIGS[capturedTab].columnKey,
+    );
+
+    if (updates.length === 0) {
+      snapshot = null;
+      return;
+    }
+
+    try {
+      await saveUpdates(updates);
+    } catch {
+      if (capturedSnapshot) {
+        allItems[capturedTab] = capturedSnapshot;
+      }
+
+      errorMessage = '保存に失敗しました';
+    } finally {
+      snapshot = null;
+    }
+  }
+</script>
+
+{#if errorMessage}
+  <Toast color="red" class="mb-4" onclose={() => (errorMessage = null)}>
+    {#snippet icon()}
+      <CircleX class="w-5 h-5" />
+    {/snippet}
+
+    {errorMessage}
+  </Toast>
+{/if}
+
+<DragDropProvider {onDragStart} {onDragOver} {onDragEnd}>
+  <KanbanTabBar
+    {activeTab}
+    {selectedSolutionCategories}
+    {selectedGrades}
+    onTabChange={(tab) => {
+      activeTab = tab;
+      updateUrl();
+    }}
+    onSolutionCategoriesChange={(columns) => {
+      selectedSolutionCategories = columns;
+      updateUrl();
+    }}
+    onGradesChange={(grades) => {
+      selectedGrades = grades;
+      updateUrl();
+    }}
+  >
+    <!-- Note: Snippets are intentional: extracting these as components would require passing too many props. -->
+    {#snippet solutionBoard()}
+      <div class="flex gap-3 overflow-x-auto pb-4">
+        {#each displayedSolutionCategories as column}
+          <KanbanColumn
+            columnId={column}
+            label={TAB_CONFIGS['solution'].labelFn(column)}
+            cards={allItems['solution'][column] ?? []}
+            group="solution"
+          />
+        {/each}
+      </div>
+    {/snippet}
+
+    {#snippet curriculumBoard()}
+      <div class="flex gap-3 overflow-x-auto pb-4">
+        {#each selectedGrades as column}
+          <KanbanColumn
+            columnId={column}
+            label={TAB_CONFIGS['curriculum'].labelFn(column)}
+            cards={allItems['curriculum'][column] ?? []}
+            group="curriculum"
+          />
+        {/each}
+      </div>
+    {/snippet}
+  </KanbanTabBar>
+</DragDropProvider>
diff --git a/src/routes/(admin)/workbooks/order/_components/KanbanCard.svelte b/src/routes/(admin)/workbooks/order/_components/KanbanCard.svelte
new file mode 100644
index 000000000..5029cfac4
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_components/KanbanCard.svelte
@@ -0,0 +1,51 @@
+<script lang="ts">
+  import { createSortable } from '@dnd-kit/svelte/sortable';
+
+  import type { Card, SortableProps } from '../_types/kanban';
+
+  import PublicationStatusLabel from '$features/workbooks/components/shared/PublicationStatusLabel.svelte';
+  import WorkbookLink from '$features/workbooks/components/shared/WorkbookLink.svelte';
+
+  let {
+    id: placementId,
+    workBookId,
+    title,
+    isPublished,
+    columnId,
+    group,
+    index,
+  }: Card & SortableProps = $props();
+
+  // See:
+  // https://dndkit.com/svelte/primitives/create-sortable#createsortable
+  const sortable = createSortable({
+    get id() {
+      return placementId;
+    },
+    get index() {
+      return index;
+    },
+    get group() {
+      return columnId;
+    },
+    get type() {
+      return group;
+    },
+  });
+
+  function attachSortable(node: HTMLElement): { destroy: () => void } {
+    const cleanup = sortable.attach(node);
+    return { destroy: cleanup };
+  }
+</script>
+
+<div
+  use:attachSortable
+  data-placement-id={placementId}
+  class="bg-white dark:bg-gray-700 shadow-sm border border-gray-200 dark:border-gray-600 rounded-lg p-3 cursor-grab hover:border-primary-400 touch-none select-none"
+  class:opacity-50={sortable.isDragging}
+>
+  <PublicationStatusLabel {isPublished} />
+
+  <WorkbookLink {workBookId} {title} />
+</div>
diff --git a/src/routes/(admin)/workbooks/order/_components/KanbanColumn.svelte b/src/routes/(admin)/workbooks/order/_components/KanbanColumn.svelte
new file mode 100644
index 000000000..4d642cf55
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_components/KanbanColumn.svelte
@@ -0,0 +1,53 @@
+<script lang="ts">
+  import { createDroppable } from '@dnd-kit/svelte';
+
+  import KanbanCard from './KanbanCard.svelte';
+
+  import type { Cards } from '../_types/kanban';
+
+  interface Props {
+    columnId: string; // droppable zone ID
+    group: string; // dnd-kit type for restricting drops
+    label: string;
+    cards: Cards;
+  }
+
+  let { columnId, group, label, cards }: Props = $props();
+
+  const droppable = createDroppable({
+    get id() {
+      return columnId;
+    },
+    type: group,
+    collisionPriority: 1, // CollisionPriority.Low
+    accept: group,
+  });
+
+  function attachDroppable(node: HTMLElement): { destroy: () => void } {
+    const cleanup = droppable.attach(node);
+    return { destroy: cleanup };
+  }
+</script>
+
+<div
+  use:attachDroppable
+  data-testid="column-{columnId}"
+  class="min-w-64 w-64 shrink-0 rounded-lg p-3 flex flex-col gap-2"
+  class:bg-gray-100={!droppable.isDropTarget}
+  class:dark:bg-gray-700={!droppable.isDropTarget}
+  class:bg-gray-200={droppable.isDropTarget}
+  class:dark:bg-gray-600={droppable.isDropTarget}
+>
+  <div class="flex items-center justify-between sticky top-0 pb-1">
+    <h3 class="text-base font-semibold text-gray-700 dark:text-gray-300">{label}</h3>
+    <span class="text-base font-semibold text-gray-500">{cards.length}</span>
+  </div>
+
+  <div class="flex flex-col gap-2 min-h-12 overflow-y-auto max-h-[60vh]">
+    {#each cards as card, i (card.id)}
+      <KanbanCard {...card} index={i} {columnId} {group} />
+    {:else}
+      <p class="text-sm text-gray-400 dark:text-gray-500 text-center py-3">問題集をドロップ</p>
+    {/each}
+  </div>
+</div>
diff --git a/src/routes/(admin)/workbooks/order/_components/KanbanTabBar.svelte b/src/routes/(admin)/workbooks/order/_components/KanbanTabBar.svelte
new file mode 100644
index 000000000..3e8714ee6
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_components/KanbanTabBar.svelte
@@ -0,0 +1,90 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+
+  import { Tabs } from 'flowbite-svelte';
+
+  import { TaskGrade } from '$lib/types/task';
+  import { SolutionCategory, SOLUTION_LABELS } from '$features/workbooks/types/workbook_placement';
+  import type { ActiveTab } from '../_types/kanban';
+
+  import TabItemWrapper from '$lib/components/Tabs/TabItemWrapper.svelte';
+  import ColumnSelector from './ColumnSelector.svelte';
+
+  import { getTaskGradeLabel } from '$lib/utils/task';
+
+  const SOLUTION_CATEGORY_OPTIONS = Object.entries(SolutionCategory)
+    .filter(([category]) => category !== SolutionCategory.PENDING)
+    .map(([category]) => ({ value: category, label: SOLUTION_LABELS[category] ?? category }));
+
+  const GRADE_OPTIONS = Object.keys(TaskGrade)
+    .filter((key) => key !== TaskGrade.PENDING)
+    .map((key) => ({ value: key, label: getTaskGradeLabel(key) }));
+
+  interface Props {
+    activeTab: ActiveTab;
+    selectedSolutionCategories: string[];
+    selectedGrades: string[];
+    onTabChange: (tab: ActiveTab) => void;
+    onSolutionCategoriesChange: (columns: string[]) => void;
+    onGradesChange: (grades: string[]) => void;
+    solutionBoard: Snippet;
+    curriculumBoard: Snippet;
+  }
+
+  let {
+    activeTab,
+    selectedSolutionCategories,
+    selectedGrades,
+    onTabChange,
+    onSolutionCategoriesChange,
+    onGradesChange,
+    solutionBoard,
+    curriculumBoard,
+  }: Props = $props();
+</script>
+
+<Tabs tabStyle="underline" class="mb-0" contentClass="bg-white dark:bg-gray-800">
+  <TabItemWrapper
+    isOpen={activeTab === 'solution'}
+    title="解法別"
+    onclick={() => onTabChange('solution')}
+  >
+    {@render solutionContent()}
+  </TabItemWrapper>
+
+  <TabItemWrapper
+    isOpen={activeTab === 'curriculum'}
+    title="カリキュラム"
+    onclick={() => onTabChange('curriculum')}
+  >
+    {@render curriculumContent()}
+  </TabItemWrapper>
+</Tabs>
+
+{#snippet solutionContent()}
+  <div class="mb-4">
+    <p class="text-sm text-gray-600 dark:text-gray-400 mb-2">
+      表示カテゴリ（1つ以上選択。「未分類」は常に表示）:
+    </p>
+    <ColumnSelector
+      options={SOLUTION_CATEGORY_OPTIONS}
+      selected={selectedSolutionCategories.filter(
+        (category) => category !== SolutionCategory.PENDING,
+      )}
+      onchange={onSolutionCategoriesChange}
+      minRequired={1}
+    />
+  </div>
+
+  {@render solutionBoard()}
+{/snippet}
+
+{#snippet curriculumContent()}
+  <div class="mb-4">
+    <p class="text-sm text-gray-600 dark:text-gray-400 mb-2">表示グレード（2つ以上選択）:</p>
+
+    <ColumnSelector options={GRADE_OPTIONS} selected={selectedGrades} onchange={onGradesChange} />
+  </div>
+
+  {@render curriculumBoard()}
+{/snippet}
diff --git a/src/routes/(admin)/workbooks/order/_fixtures/kanban.ts b/src/routes/(admin)/workbooks/order/_fixtures/kanban.ts
new file mode 100644
index 000000000..5940b9779
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_fixtures/kanban.ts
@@ -0,0 +1,82 @@
+import { TaskGrade } from '$lib/types/task';
+import { WorkBookType } from '$features/workbooks/types/workbook';
+import {
+  SolutionCategory,
+  type WorkbooksWithPlacement,
+} from '$features/workbooks/types/workbook_placement';
+import type { KanbanColumns } from '../_types/kanban';
+
+// Workbooks used in buildKanbanItems tests.
+// Covers SOLUTION (GRAPH, DYNAMIC_PROGRAMMING, PENDING), CURRICULUM (Q10), and null placement.
+export const workbooks: WorkbooksWithPlacement = [
+  {
+    id: 1,
+    title: 'Graph Basics',
+    isPublished: true,
+    workBookType: WorkBookType.SOLUTION,
+    placement: {
+      id: 101,
+      workBookId: 1,
+      solutionCategory: SolutionCategory.GRAPH,
+      taskGrade: null,
+      priority: 1,
+    },
+  },
+  {
+    id: 2,
+    title: 'DP Intro',
+    isPublished: false,
+    workBookType: WorkBookType.SOLUTION,
+    placement: {
+      id: 102,
+      workBookId: 2,
+      solutionCategory: SolutionCategory.DYNAMIC_PROGRAMMING,
+      taskGrade: null,
+      priority: 2,
+    },
+  },
+  {
+    id: 3,
+    title: 'Pending Book',
+    isPublished: true,
+    workBookType: WorkBookType.SOLUTION,
+    placement: {
+      id: 103,
+      workBookId: 3,
+      solutionCategory: SolutionCategory.PENDING,
+      taskGrade: null,
+      priority: 1,
+    },
+  },
+  {
+    id: 4,
+    title: 'Curriculum Q10',
+    isPublished: true,
+    workBookType: WorkBookType.CURRICULUM,
+    placement: {
+      id: 201,
+      workBookId: 4,
+      solutionCategory: null,
+      taskGrade: TaskGrade.Q10,
+      priority: 1,
+    },
+  },
+  {
+    id: 5,
+    title: 'No placement',
+    isPublished: true,
+    workBookType: WorkBookType.SOLUTION,
+    placement: null,
+  },
+];
+
+// KanbanColumns snapshot used as the "before drag" baseline in reCalcPriorities tests.
+export const solutionColumnsBefore: KanbanColumns = {
+  [SolutionCategory.GRAPH]: [
+    { id: 101, workBookId: 1, title: 'Graph Basics', isPublished: true },
+    { id: 102, workBookId: 2, title: 'Graph Advanced', isPublished: false },
+  ],
+  [SolutionCategory.PENDING]: [
+    { id: 103, workBookId: 3, title: 'Pending Book', isPublished: true },
+  ],
+};
diff --git a/src/routes/(admin)/workbooks/order/_types/kanban.ts b/src/routes/(admin)/workbooks/order/_types/kanban.ts
new file mode 100644
index 000000000..26d81be46
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_types/kanban.ts
@@ -0,0 +1,49 @@
+import type { DragDropManager, Draggable, Droppable } from '@dnd-kit/dom';
+import type { DragDropEvents } from '@dnd-kit/abstract';
+
+// DnD event types derived from dnd-kit abstractions
+type DndEvents = DragDropEvents<Draggable, Droppable, DragDropManager>;
+
+export type DragOverEventArg = Parameters<DndEvents['dragover']>[0];
+export type DragEndEventArg = Parameters<DndEvents['dragend']>[0];
+
+export type ColumnKey = 'solutionCategory' | 'taskGrade';
+
+export type ActiveTab = 'solution' | 'curriculum';
+
+// Static per-tab configuration used to eliminate activeTab === 'solution' if-branches
+export type TabConfig = {
+  labelFn: (column: string) => string;
+  group: string;
+  columnKey: ColumnKey;
+};
+
+export type KanbanColumns = Record<string, Cards>;
+
+// Placement update sent to the server after a drag-and-drop operation
+export type PlacementUpdate = {
+  id: number;
+  priority: number;
+  solutionCategory: string | null;
+  taskGrade: string | null;
+};
+
+export type PlacementUpdates = PlacementUpdate[];
+
+// Props required for dnd-kit sortable positioning
+export type SortableProps = {
+  columnId: string; // droppable zone ID (the column this card belongs to)
+  group: string; // dnd-kit type that restricts drop targets to the same board
+  index: number; // position within the column (required by dnd-kit sortable)
+};
+
+// Card used in the Kanban board (one card = one WorkBookPlacement)
+// Column assignment is implicit in the Record key, not stored on the card.
+export type Card = {
+  id: number; // placement.id
+  workBookId: number;
+  title: string;
+  isPublished: boolean;
+};
+
+export type Cards = Card[];
diff --git a/src/routes/(admin)/workbooks/order/_utils/kanban.test.ts b/src/routes/(admin)/workbooks/order/_utils/kanban.test.ts
new file mode 100644
index 000000000..0bd533308
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_utils/kanban.test.ts
@@ -0,0 +1,338 @@
+import { describe, test, expect } from 'vitest';
+
+import { SolutionCategory } from '$features/workbooks/types/workbook_placement';
+import { TaskGrade } from '$lib/types/task';
+
+import { workbooks, solutionColumnsBefore } from '../_fixtures/kanban';
+import {
+  buildKanbanItems,
+  buildUpdatedUrl,
+  parseInitialCategories,
+  parseInitialGrades,
+  parseTab,
+  reCalcPriorities,
+} from './kanban';
+
+describe('parseTab', () => {
+  test('returns the param when it is a valid tab key', () => {
+    expect(parseTab('solution')).toBe('solution');
+    expect(parseTab('curriculum')).toBe('curriculum');
+  });
+
+  test('falls back to solution for null', () => {
+    expect(parseTab(null)).toBe('solution');
+  });
+
+  test('falls back to solution for an unknown string', () => {
+    expect(parseTab('unknown')).toBe('solution');
+    expect(parseTab('')).toBe('solution');
+  });
+});
+
+describe('parseInitialCategories', () => {
+  test('returns parsed categories when param is present', () => {
+    const params = new URLSearchParams(
+      `categories=${SolutionCategory.GRAPH},${SolutionCategory.DYNAMIC_PROGRAMMING}`,
+    );
+    expect(parseInitialCategories(params)).toEqual([
+      SolutionCategory.GRAPH,
+      SolutionCategory.DYNAMIC_PROGRAMMING,
+    ]);
+  });
+
+  test('returns default categories when param is absent', () => {
+    const params = new URLSearchParams();
+    expect(parseInitialCategories(params)).toEqual([
+      SolutionCategory.PENDING,
+      SolutionCategory.GRAPH,
+    ]);
+  });
+
+  test('drops invalid category values', () => {
+    const params = new URLSearchParams(`categories=${SolutionCategory.GRAPH},INVALID`);
+    expect(parseInitialCategories(params)).toEqual([SolutionCategory.GRAPH]);
+  });
+
+  test('returns empty array when all values are invalid', () => {
+    const params = new URLSearchParams('categories=INVALID');
+    expect(parseInitialCategories(params)).toEqual([]);
+  });
+
+  test('ignores empty strings from trailing commas', () => {
+    const params = new URLSearchParams(`categories=${SolutionCategory.GRAPH},`);
+    expect(parseInitialCategories(params)).toEqual([SolutionCategory.GRAPH]);
+  });
+});
+
+describe('parseInitialGrades', () => {
+  test('returns parsed grades when param is present', () => {
+    const params = new URLSearchParams(`grades=${TaskGrade.Q10},${TaskGrade.Q9}`);
+    expect(parseInitialGrades(params)).toEqual([TaskGrade.Q10, TaskGrade.Q9]);
+  });
+
+  test('returns default grades when param is absent', () => {
+    const params = new URLSearchParams();
+    expect(parseInitialGrades(params)).toEqual([TaskGrade.Q10, TaskGrade.Q9]);
+  });
+
+  test('drops PENDING even when explicitly included', () => {
+    const params = new URLSearchParams(`grades=${TaskGrade.PENDING},${TaskGrade.Q10}`);
+    expect(parseInitialGrades(params)).toEqual([TaskGrade.Q10]);
+  });
+
+  test('drops invalid grade values', () => {
+    const params = new URLSearchParams(`grades=${TaskGrade.Q10},INVALID`);
+    expect(parseInitialGrades(params)).toEqual([TaskGrade.Q10]);
+  });
+
+  test('returns empty array when all values are invalid or PENDING', () => {
+    const params = new URLSearchParams(`grades=${TaskGrade.PENDING},INVALID`);
+    expect(parseInitialGrades(params)).toEqual([]);
+  });
+});
+
+describe('buildUpdatedUrl', () => {
+  const baseUrl = new URL('https://example.com/workbooks/order');
+
+  test('solution tab: sets tab and categories, deletes grades', () => {
+    const result = buildUpdatedUrl(
+      baseUrl,
+      'solution',
+      [SolutionCategory.GRAPH, SolutionCategory.PENDING],
+      [],
+    );
+    expect(result.searchParams.get('tab')).toBe('solution');
+    expect(result.searchParams.get('categories')).toBe(
+      `${SolutionCategory.GRAPH},${SolutionCategory.PENDING}`,
+    );
+    expect(result.searchParams.has('grades')).toBe(false);
+  });
+
+  test('curriculum tab: sets tab and grades, deletes categories', () => {
+    const result = buildUpdatedUrl(baseUrl, 'curriculum', [], [TaskGrade.Q10, TaskGrade.Q9]);
+    expect(result.searchParams.get('tab')).toBe('curriculum');
+    expect(result.searchParams.get('grades')).toBe(`${TaskGrade.Q10},${TaskGrade.Q9}`);
+    expect(result.searchParams.has('categories')).toBe(false);
+  });
+
+  test('solution tab with empty categories produces empty string value', () => {
+    const result = buildUpdatedUrl(baseUrl, 'solution', [], []);
+    expect(result.searchParams.get('categories')).toBe('');
+  });
+
+  test('overwrites existing params without duplicating', () => {
+    const url = new URL(
+      `https://example.com/workbooks/order?tab=curriculum&grades=${TaskGrade.Q10}&categories=${SolutionCategory.GRAPH}`,
+    );
+    const result = buildUpdatedUrl(url, 'solution', [SolutionCategory.PENDING], []);
+    expect(result.searchParams.getAll('tab')).toHaveLength(1);
+    expect(result.searchParams.get('tab')).toBe('solution');
+    expect(result.searchParams.has('grades')).toBe(false);
+  });
+
+  test('does not mutate the original URL', () => {
+    const url = new URL('https://example.com/workbooks/order?tab=curriculum');
+    buildUpdatedUrl(url, 'solution', [SolutionCategory.GRAPH], []);
+    expect(url.searchParams.get('tab')).toBe('curriculum');
+  });
+});
+
+describe('buildKanbanItems', () => {
+  test('initializes all enum keys as empty arrays', () => {
+    const result = buildKanbanItems([], ['PENDING', 'GRAPH', 'DATA_STRUCTURE'], () => null);
+    expect(result).toEqual({ PENDING: [], GRAPH: [], DATA_STRUCTURE: [] });
+  });
+
+  test('groups workbooks by solutionCategory', () => {
+    const result = buildKanbanItems(
+      workbooks,
+      [SolutionCategory.PENDING, SolutionCategory.GRAPH, SolutionCategory.DYNAMIC_PROGRAMMING],
+      (workbook) => workbook.placement?.solutionCategory ?? null,
+    );
+
+    expect(result[SolutionCategory.PENDING]).toHaveLength(1);
+    expect(result[SolutionCategory.PENDING][0]).toMatchObject({
+      id: 103,
+      workBookId: 3,
+      title: 'Pending Book',
+    });
+    expect(result[SolutionCategory.GRAPH]).toHaveLength(1);
+    expect(result[SolutionCategory.GRAPH][0]).toMatchObject({
+      id: 101,
+      workBookId: 1,
+      title: 'Graph Basics',
+    });
+    expect(result[SolutionCategory.DYNAMIC_PROGRAMMING]).toHaveLength(1);
+    expect(result[SolutionCategory.DYNAMIC_PROGRAMMING][0]).toMatchObject({
+      id: 102,
+      workBookId: 2,
+    });
+  });
+
+  test('excludes workbooks with null column key (no placement or wrong type)', () => {
+    const result = buildKanbanItems(
+      workbooks,
+      [TaskGrade.Q10, TaskGrade.Q9],
+      (workbook) => workbook.placement?.taskGrade ?? null,
+    );
+
+    expect(result[TaskGrade.Q10]).toHaveLength(1);
+    expect(result[TaskGrade.Q10][0]).toMatchObject({
+      id: 201,
+      workBookId: 4,
+      title: 'Curriculum Q10',
+    });
+    expect(result[TaskGrade.Q9]).toHaveLength(0);
+  });
+
+  test('sorts workbooks by placement priority within each column', () => {
+    // Two GRAPH workbooks inserted in reverse priority order: priority 2 first, priority 1 second.
+    const reversed = [
+      { ...workbooks[0], placement: { ...workbooks[0].placement!, priority: 2 } },
+      {
+        ...workbooks[0],
+        id: 99,
+        placement: { ...workbooks[0].placement!, id: 999, workBookId: 99, priority: 1 },
+      },
+    ];
+    const result = buildKanbanItems(
+      reversed,
+      [SolutionCategory.GRAPH],
+      (workbook) => workbook.placement?.solutionCategory ?? null,
+    );
+    expect(result[SolutionCategory.GRAPH][0].id).toBe(999); // priority 1 first
+    expect(result[SolutionCategory.GRAPH][1].id).toBe(101); // priority 2 second
+  });
+
+  test('card includes isPublished field', () => {
+    // workbooks[0]: Graph Basics, isPublished: true
+    const result = buildKanbanItems(
+      [workbooks[0]],
+      [SolutionCategory.GRAPH],
+      (workbook) => workbook.placement?.solutionCategory ?? null,
+    );
+    expect(result[SolutionCategory.GRAPH][0].isPublished).toBe(true);
+  });
+
+  test('does not include workbooks where placement is null', () => {
+    // workbooks[4]: No placement, placement: null
+    const result = buildKanbanItems(
+      [workbooks[4]],
+      [SolutionCategory.GRAPH],
+      (workbook) => workbook.placement?.solutionCategory ?? null,
+    );
+    expect(result[SolutionCategory.GRAPH]).toHaveLength(0);
+  });
+});
+
+describe('reCalcPriorities', () => {
+  const before = solutionColumnsBefore;
+
+  test('returns empty array when nothing changed', () => {
+    const after = structuredClone(before);
+    expect(reCalcPriorities(before, after, 'solutionCategory')).toEqual([]);
+  });
+
+  test('returns updates for reordered cards within a column', () => {
+    const after = {
+      ...before,
+      [SolutionCategory.GRAPH]: [
+        before[SolutionCategory.GRAPH][1],
+        before[SolutionCategory.GRAPH][0],
+      ], // swapped
+    };
+
+    const updates = reCalcPriorities(before, after, 'solutionCategory');
+    expect(updates).toHaveLength(2);
+    expect(updates[0]).toMatchObject({
+      id: 102,
+      priority: 1,
+      solutionCategory: SolutionCategory.GRAPH,
+      taskGrade: null,
+    });
+    expect(updates[1]).toMatchObject({
+      id: 101,
+      priority: 2,
+      solutionCategory: SolutionCategory.GRAPH,
+      taskGrade: null,
+    });
+  });
+
+  test('returns updates only for changed columns', () => {
+    const after = {
+      [SolutionCategory.GRAPH]: [
+        before[SolutionCategory.GRAPH][1],
+        before[SolutionCategory.GRAPH][0],
+      ], // changed
+      [SolutionCategory.PENDING]: before[SolutionCategory.PENDING], // unchanged
+    };
+
+    const updates = reCalcPriorities(before, after, 'solutionCategory');
+    const updatedIds = updates.map((update) => update.id);
+    expect(updatedIds).not.toContain(103);
+    expect(updatedIds).toContain(101);
+    expect(updatedIds).toContain(102);
+  });
+
+  test('sets taskGrade instead of solutionCategory when columnKey is taskGrade', () => {
+    const gradeBefore = {
+      [TaskGrade.Q10]: [{ id: 201, workBookId: 4, title: 'Q10 Book', isPublished: true }],
+      [TaskGrade.Q9]: [{ id: 202, workBookId: 5, title: 'Q9 Book', isPublished: true }],
+    };
+    const gradeAfter = {
+      [TaskGrade.Q10]: [{ id: 202, workBookId: 5, title: 'Q9 Book', isPublished: true }], // moved from Q9
+      [TaskGrade.Q9]: [{ id: 201, workBookId: 4, title: 'Q10 Book', isPublished: true }],
+    };
+
+    const updates = reCalcPriorities(gradeBefore, gradeAfter, 'taskGrade');
+    expect(updates.every((update) => update.solutionCategory === null)).toBe(true);
+    expect(updates.find((update) => update.id === 202)).toMatchObject({
+      taskGrade: TaskGrade.Q10,
+      solutionCategory: null,
+    });
+  });
+
+  test('returns updates for columns missing from before (new column)', () => {
+    const updates = reCalcPriorities(
+      {},
+      {
+        [SolutionCategory.GRAPH]: [{ id: 101, workBookId: 1, title: 'Test', isPublished: true }],
+      },
+      'solutionCategory',
+    );
+    expect(updates).toHaveLength(1);
+    expect(updates[0]).toMatchObject({
+      id: 101,
+      priority: 1,
+      solutionCategory: SolutionCategory.GRAPH,
+    });
+  });
+
+  test('returns updates for both columns when a card is moved across columns', () => {
+    const crossBefore = {
+      [SolutionCategory.GRAPH]: [
+        { id: 101, workBookId: 1, title: 'Graph Basics', isPublished: true },
+      ],
+      [SolutionCategory.PENDING]: [],
+    };
+    const crossAfter = {
+      [SolutionCategory.GRAPH]: [],
+      [SolutionCategory.PENDING]: [
+        { id: 101, workBookId: 1, title: 'Graph Basics', isPublished: true },
+      ],
+    };
+
+    const updates = reCalcPriorities(crossBefore, crossAfter, 'solutionCategory');
+    // GRAPH is now empty (changed), PENDING gained a card (changed) → both produce updates
+    expect(updates).toHaveLength(1);
+    expect(updates[0]).toMatchObject({
+      id: 101,
+      priority: 1,
+      solutionCategory: SolutionCategory.PENDING,
+    });
+  });
+
+  test('returns empty array when after is empty and before is empty', () => {
+    expect(reCalcPriorities({}, {}, 'solutionCategory')).toEqual([]);
+  });
+});
diff --git a/src/routes/(admin)/workbooks/order/_utils/kanban.ts b/src/routes/(admin)/workbooks/order/_utils/kanban.ts
new file mode 100644
index 000000000..f2be07383
--- /dev/null
+++ b/src/routes/(admin)/workbooks/order/_utils/kanban.ts
@@ -0,0 +1,191 @@
+import { TaskGrade } from '$lib/types/task';
+import {
+  SolutionCategory,
+  SOLUTION_LABELS,
+  type WorkbooksWithPlacement,
+  type WorkbookWithPlacement,
+} from '$features/workbooks/types/workbook_placement';
+import type {
+  ActiveTab,
+  KanbanColumns,
+  ColumnKey,
+  PlacementUpdates,
+  TabConfig,
+} from '../_types/kanban';
+
+import { getTaskGradeLabel } from '$lib/utils/task';
+
+// Per-tab static configuration; eliminates activeTab === 'solution' branches in DnD handlers
+export const TAB_CONFIGS: Record<ActiveTab, TabConfig> = {
+  solution: {
+    labelFn: (column) => SOLUTION_LABELS[column] ?? column,
+    group: 'solution',
+    columnKey: 'solutionCategory',
+  },
+  curriculum: {
+    labelFn: getTaskGradeLabel,
+    group: 'curriculum',
+    columnKey: 'taskGrade',
+  },
+};
+
+/**
+ * Parses the `tab` search param into a valid {@link ActiveTab}.
+ *
+ * @param param - Raw value of the `tab` search param, or `null` if absent.
+ * @returns The matching `ActiveTab`, or `'solution'` for unknown/missing values.
+ */
+export function parseTab(param: string | null): ActiveTab {
+  if (param !== null && Object.hasOwn(TAB_CONFIGS, param)) {
+    return param as ActiveTab;
+  }
+
+  return 'solution';
+}
+
+// Default columns shown when no 'categories' param is present in the URL.
+const DEFAULT_SOLUTION_CATEGORIES: string[] = [SolutionCategory.PENDING, SolutionCategory.GRAPH];
+
+/**
+ * Parses the `categories` search param into a validated list of {@link SolutionCategory} keys.
+ *
+ * @param params - The URL search params to read from.
+ * @returns Validated category keys. Falls back to `DEFAULT_SOLUTION_CATEGORIES` when the param is
+ *   absent; invalid values are silently dropped.
+ */
+export function parseInitialCategories(params: URLSearchParams): string[] {
+  return (
+    params.get('categories')?.split(',').filter(Boolean) ?? DEFAULT_SOLUTION_CATEGORIES
+  ).filter((category) => Object.hasOwn(SolutionCategory, category));
+}
+
+// Default grades shown when no 'grades' param is present in the URL.
+const DEFAULT_GRADES: string[] = [TaskGrade.Q10, TaskGrade.Q9];
+
+/**
+ * Parses the `grades` search param into a validated list of {@link TaskGrade} keys.
+ *
+ * @param params - The URL search params to read from.
+ * @returns Validated grade keys. Falls back to `DEFAULT_GRADES` when the param is absent;
+ *   `PENDING` and invalid values are silently dropped.
+ */
+export function parseInitialGrades(params: URLSearchParams): string[] {
+  return (params.get('grades')?.split(',').filter(Boolean) ?? DEFAULT_GRADES).filter(
+    (grade) => Object.hasOwn(TaskGrade, grade) && grade !== TaskGrade.PENDING,
+  );
+}
+
+/**
+ * Returns a new URL with tab/category/grade search params updated.
+ * Pure function — does not call replaceState.
+ */
+export function buildUpdatedUrl(
+  url: URL,
+  activeTab: ActiveTab,
+  selectedSolutionCategories: string[],
+  selectedGrades: string[],
+): URL {
+  const updatedUrl = new URL(url);
+  updatedUrl.searchParams.set('tab', activeTab);
+
+  if (activeTab === 'solution') {
+    updatedUrl.searchParams.set('categories', selectedSolutionCategories.join(','));
+    updatedUrl.searchParams.delete('grades');
+  } else {
+    updatedUrl.searchParams.set('grades', selectedGrades.join(','));
+    updatedUrl.searchParams.delete('categories');
+  }
+
+  return updatedUrl;
+}
+
+/**
+ * Builds a KanbanColumns record from a list of workbooks.
+ *
+ * @param workbooks - Workbooks with their placement data
+ * @param enumKeys - All column keys to initialize (including empty columns)
+ * @param getColumnKey - Extracts the column key from a workbook; returns null to exclude
+ *
+ * @returns A record mapping column keys to arrays of cards, sorted by priority
+ */
+export function buildKanbanItems(
+  workbooks: WorkbooksWithPlacement,
+  columnKeys: string[],
+  getColumnKey: (workbook: WorkbookWithPlacement) => string | null,
+): KanbanColumns {
+  const record: KanbanColumns = {};
+
+  for (const key of columnKeys) {
+    record[key] = [];
+  }
+
+  workbooks
+    .filter((workbook) => workbook.placement !== null && getColumnKey(workbook) !== null)
+    .sort((a, b) => a.placement!.priority - b.placement!.priority)
+    .forEach((workbook) => {
+      const column = getColumnKey(workbook)!;
+
+      record[column].push({
+        id: workbook.placement!.id,
+        workBookId: workbook.id,
+        title: workbook.title,
+        isPublished: workbook.isPublished,
+      });
+    });
+
+  return record;
+}
+
+/**
+ * Compares two KanbanColumns snapshots and returns the placement updates needed
+ * to persist the new ordering to the server.
+ *
+ * @param before - Snapshot taken before the drag operation
+ * @param after - Current state after the drag operation
+ * @param columnKey - Which placement field ('solutionCategory' | 'taskGrade') to set
+ */
+export function reCalcPriorities(
+  before: KanbanColumns,
+  after: KanbanColumns,
+  columnKey: ColumnKey,
+): PlacementUpdates {
+  // The object literal sets both fields to null, then [columnKey]: columnId overrides one.
+  // JavaScript evaluates the object as a single expression, so the final value always has
+  // exactly one field set to columnId. workBookPlacementSchema also enforces this invariant
+  // at the API boundary before any DB write occurs.
+  return Object.entries(after).flatMap(([columnId, cards]) => {
+    const snapCards = before[columnId];
+    const isUpdated =
+      !snapCards ||
+      cards.length !== snapCards.length ||
+      cards.some((card, i) => card.id !== snapCards[i]?.id);
+
+    if (!isUpdated) {
+      return [];
+    }
+
+    return cards.map((card, i) => ({
+      id: card.id,
+      priority: i + 1,
+      solutionCategory: null,
+      taskGrade: null,
+      [columnKey]: columnId,
+    }));
+  });
+}
+
+/**
+ * Sends placement updates to the server.
+ * Throws if the response is not OK.
+ */
+export async function saveUpdates(updates: PlacementUpdates): Promise<void> {
+  const response = await fetch('/workbooks/order', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ updates }),
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to save');
+  }
+}
diff --git a/src/routes/workbooks/+page.server.ts b/src/routes/workbooks/+page.server.ts
index da8f8ef19..a2e7b046a 100644
--- a/src/routes/workbooks/+page.server.ts
+++ b/src/routes/workbooks/+page.server.ts
@@ -36,7 +36,7 @@ export async function load({ locals }) {
 
   try {
     // 問題集を構成する問題のグレードの最頻値を取得するために使用
-    const tasksByTaskId = await taskCrud.getTasksByTaskId();
+    const tasksMapByIds = await taskCrud.getTasksByTaskId();
     // ユーザの回答状況を表示するために使用
     const taskResultsByTaskId = await taskResultsCrud.getTaskResultsOnlyResultExists(
       loggedInUser?.id as string,
@@ -45,7 +45,7 @@ export async function load({ locals }) {
 
     return {
       workbooks: workbooksWithAuthors,
-      tasksByTaskId: tasksByTaskId,
+      tasksMapByIds: tasksMapByIds,
       taskResultsByTaskId: taskResultsByTaskId,
       loggedInUser: loggedInUser,
     };
diff --git a/src/routes/workbooks/+page.svelte b/src/routes/workbooks/+page.svelte
index a64fa2f55..5cdd6cc0c 100644
--- a/src/routes/workbooks/+page.svelte
+++ b/src/routes/workbooks/+page.svelte
@@ -3,13 +3,7 @@
   import { Button, Tabs } from 'flowbite-svelte';
 
   import { Roles } from '$lib/types/user';
-  import {
-    type Task,
-    TaskGrade,
-    type TaskGrades,
-    type TaskResult,
-    type TaskResults,
-  } from '$lib/types/task';
+  import { type Task, type TaskResult, type TaskResults } from '$lib/types/task';
   import {
     type WorkbookList,
     type WorkbooksList,
@@ -23,8 +17,7 @@
   import WorkbookTabItem from '$features/workbooks/components/list/WorkbookTabItem.svelte';
   import WorkBookList from '$features/workbooks/components/list/WorkBookList.svelte';
 
-  import { calcGradeMode } from '$lib/utils/task';
-  import { canViewWorkBook } from '$features/workbooks/utils/workbooks';
+  import { canViewWorkBook, calcWorkBookGradeModes } from '$features/workbooks/utils/workbooks';
 
   let { data } = $props();
 
@@ -66,34 +59,10 @@
     return get(activeWorkbookTabStore).get(workBookType);
   };
 
-  const tasksByTaskId: Map<string, Task> = data.tasksByTaskId;
+  const tasksMapByIds: Map<string, Task> = data.tasksMapByIds;
   let taskResultsByTaskId = data.taskResultsByTaskId as Map<string, TaskResult>;
 
-  // 計算量: 問題集の数をN、各問題集の問題の平均値をMとすると、O(N * M * log(M))
-  const getWorkBookGradeModes = (workbooks: WorkbooksList): Map<number, TaskGrade> => {
-    const gradeModes: Map<number, TaskGrade> = new Map();
-
-    workbooks.forEach((workbook: WorkbookList) => {
-      const taskGrades = workbook.workBookTasks.reduce(
-        (results: TaskGrades, workBookTask: WorkBookTaskBase) => {
-          const task = tasksByTaskId.get(workBookTask.taskId);
-
-          if (task && task.grade !== TaskGrade.PENDING) {
-            results.push(task.grade as TaskGrade);
-          }
-          return results;
-        },
-        [],
-      );
-
-      const gradeMode = calcGradeMode(taskGrades as TaskGrades);
-      gradeModes.set(workbook.id, gradeMode);
-    });
-
-    return gradeModes;
-  };
-
-  const workbookGradeModes = getWorkBookGradeModes(data.workbooks as WorkbooksList);
+  const workbookGradeModes = calcWorkBookGradeModes(data.workbooks as WorkbooksList, tasksMapByIds);
 
   // 計算量: 問題集の数をN、各問題集の問題の平均値をMとすると、O(N * M)
   function fetchTaskResultsWithWorkBookId(workbooks: WorkbooksList, workBookType: WorkBookType) {
diff --git a/tests/workbook_order.test.ts b/tests/workbook_order.test.ts
new file mode 100644
index 000000000..3d338ff56
--- /dev/null
+++ b/tests/workbook_order.test.ts
@@ -0,0 +1,338 @@
+import { test, expect, Page } from '@playwright/test';
+
+import { SolutionCategory } from '../src/features/workbooks/types/workbook_placement';
+import { TaskGrade } from '../src/lib/types/task';
+
+import { BAD_REQUEST, OK } from '../src/lib/constants/http-response-status-codes';
+
+const TIMEOUT = 60 * 1000;
+const ORDER_URL = '/workbooks/order';
+
+test.describe('access control', () => {
+  test('unauthenticated user is redirected to /login', async ({ page }) => {
+    await page.goto(ORDER_URL);
+    await expect(page).toHaveURL('/login', { timeout: TIMEOUT });
+  });
+});
+
+test.describe('workbook order page', () => {
+  test.beforeEach(async ({ page }) => {
+    await loginAsAdmin(page);
+  });
+
+  test('reordering within the same column persists after reload', async ({ page }) => {
+    await page.goto(`${ORDER_URL}?tab=solution&categories=${SolutionCategory.PENDING}`);
+    await expect(page.getByRole('heading', { name: '未分類' })).toBeVisible({ timeout: TIMEOUT });
+
+    const cards = await getCardsInColumn(page, SolutionCategory.PENDING);
+
+    if (cards.length < 2) {
+      test.skip();
+      return;
+    }
+
+    const [first, second] = cards;
+
+    // Swap the first two cards via API
+    await postUpdates(page, [
+      {
+        id: first.placementId,
+        priority: 2,
+        solutionCategory: SolutionCategory.PENDING,
+        taskGrade: null,
+      },
+      {
+        id: second.placementId,
+        priority: 1,
+        solutionCategory: SolutionCategory.PENDING,
+        taskGrade: null,
+      },
+    ]);
+
+    try {
+      await page.reload();
+      await expect(page.getByRole('heading', { name: '未分類' })).toBeVisible({ timeout: TIMEOUT });
+
+      const reloaded = await getCardsInColumn(page, SolutionCategory.PENDING);
+      expect(reloaded[0].placementId).toBe(second.placementId);
+      expect(reloaded[1].placementId).toBe(first.placementId);
+    } finally {
+      // Restore
+      await postUpdates(page, [
+        {
+          id: first.placementId,
+          priority: 1,
+          solutionCategory: SolutionCategory.PENDING,
+          taskGrade: null,
+        },
+        {
+          id: second.placementId,
+          priority: 2,
+          solutionCategory: SolutionCategory.PENDING,
+          taskGrade: null,
+        },
+      ]);
+    }
+  });
+
+  test('moving a card to a different column persists after reload', async ({ page }) => {
+    await page.goto(
+      `${ORDER_URL}?tab=solution&categories=${SolutionCategory.PENDING},${SolutionCategory.GRAPH}`,
+    );
+    await expect(page.getByRole('heading', { name: '未分類' })).toBeVisible({ timeout: TIMEOUT });
+
+    const pendingCards = await getCardsInColumn(page, SolutionCategory.PENDING);
+
+    if (pendingCards.length === 0) {
+      test.skip();
+      return;
+    }
+
+    const pendingCard = pendingCards[0];
+
+    // Move card to GRAPH via API
+    await postUpdates(page, [
+      {
+        id: pendingCard.placementId,
+        priority: 1,
+        solutionCategory: SolutionCategory.GRAPH,
+        taskGrade: null,
+      },
+    ]);
+
+    try {
+      await page.reload();
+      await expect(page.getByRole('heading', { name: 'グラフ' })).toBeVisible({ timeout: TIMEOUT });
+
+      const graphCards = await getCardsInColumn(page, SolutionCategory.GRAPH);
+      expect(graphCards.some((card) => card.placementId === pendingCard.placementId)).toBe(true);
+    } finally {
+      // Restore to original PENDING column
+      await postUpdates(page, [
+        {
+          id: pendingCard.placementId,
+          priority: 1,
+          solutionCategory: SolutionCategory.PENDING,
+          taskGrade: null,
+        },
+      ]);
+    }
+  });
+
+  test('reordering in curriculum tab persists after reload', async ({ page }) => {
+    await page.goto(`${ORDER_URL}?tab=curriculum&grades=${TaskGrade.Q10},${TaskGrade.Q9}`);
+    await expect(page.getByRole('heading', { name: '10Q' })).toBeVisible({ timeout: TIMEOUT });
+
+    const cards = await getCardsInColumn(page, TaskGrade.Q10);
+
+    if (cards.length < 2) {
+      test.skip();
+      return;
+    }
+
+    const [first, second] = cards;
+
+    // Swap via API
+    await postUpdates(page, [
+      { id: first.placementId, priority: 2, solutionCategory: null, taskGrade: TaskGrade.Q10 },
+      { id: second.placementId, priority: 1, solutionCategory: null, taskGrade: TaskGrade.Q10 },
+    ]);
+
+    try {
+      await page.reload();
+      await expect(page.getByRole('heading', { name: '10Q' })).toBeVisible({ timeout: TIMEOUT });
+
+      const reloaded = await getCardsInColumn(page, TaskGrade.Q10);
+      expect(reloaded[0].placementId).toBe(second.placementId);
+      expect(reloaded[1].placementId).toBe(first.placementId);
+    } finally {
+      // Restore
+      await postUpdates(page, [
+        { id: first.placementId, priority: 1, solutionCategory: null, taskGrade: TaskGrade.Q10 },
+        { id: second.placementId, priority: 2, solutionCategory: null, taskGrade: TaskGrade.Q10 },
+      ]);
+    }
+  });
+
+  test('switching from solution to curriculum tab removes categories from URL', async ({
+    page,
+  }) => {
+    await page.goto(
+      `${ORDER_URL}?tab=solution&categories=${SolutionCategory.PENDING},${SolutionCategory.GRAPH}&grades=${TaskGrade.Q10},${TaskGrade.Q9}`,
+    );
+    await expect(page.getByRole('heading', { name: '未分類' })).toBeVisible({ timeout: TIMEOUT });
+
+    await page.getByRole('tab', { name: 'カリキュラム' }).click();
+
+    const url = new URL(page.url());
+    expect(url.searchParams.has('categories')).toBe(false);
+    expect(url.searchParams.get('tab')).toBe('curriculum');
+  });
+
+  test('switching from curriculum to solution tab removes grades from URL', async ({ page }) => {
+    await page.goto(
+      `${ORDER_URL}?tab=curriculum&categories=${SolutionCategory.PENDING},${SolutionCategory.GRAPH}&grades=${TaskGrade.Q10},${TaskGrade.Q9}`,
+    );
+    await expect(page.getByRole('heading', { name: '10Q' })).toBeVisible({ timeout: TIMEOUT });
+
+    await page.getByRole('tab', { name: '解法別' }).click();
+
+    const url = new URL(page.url());
+    expect(url.searchParams.has('grades')).toBe(false);
+    expect(url.searchParams.get('tab')).toBe('solution');
+  });
+
+  test('renders solution tab with PENDING and GRAPH columns by default when accessing without query string', async ({
+    page,
+  }) => {
+    await page.goto(ORDER_URL);
+    // Default state: solution tab active, PENDING (未分類) and GRAPH (グラフ) columns visible
+    await expect(page.getByRole('heading', { name: '未分類' })).toBeVisible({ timeout: TIMEOUT });
+    await expect(page.getByRole('heading', { name: 'グラフ' })).toBeVisible({ timeout: TIMEOUT });
+  });
+
+  test('clicking a category button toggles the column and updates URL', async ({ page }) => {
+    // Start with two selectable columns (GRAPH + DATA_STRUCTURE) so minRequired=1 allows deselection
+    await page.goto(
+      `${ORDER_URL}?tab=solution&categories=${SolutionCategory.PENDING},${SolutionCategory.GRAPH},${SolutionCategory.DATA_STRUCTURE}`,
+    );
+    await expect(page.getByRole('heading', { name: 'グラフ' })).toBeVisible({ timeout: TIMEOUT });
+    await expect(page.getByRole('heading', { name: 'データ構造' })).toBeVisible({
+      timeout: TIMEOUT,
+    });
+
+    // Deselect DATA_STRUCTURE — GRAPH remains so minRequired is satisfied
+    await page.getByRole('button', { name: 'データ構造' }).click();
+
+    // データ構造 column should disappear
+    await expect(page.getByRole('heading', { name: 'データ構造' })).not.toBeVisible();
+
+    // URL should reflect the new selection
+    const url = new URL(page.url());
+    const categories = url.searchParams.get('categories') ?? '';
+    expect(categories.split(',')).not.toContain(SolutionCategory.DATA_STRUCTURE);
+    expect(categories.split(',')).toContain(SolutionCategory.GRAPH);
+  });
+});
+
+test.describe('API error handling', () => {
+  test.beforeEach(async ({ page }) => {
+    await loginAsAdmin(page);
+    await page.goto(ORDER_URL);
+    await expect(page.getByRole('heading', { name: '未分類' })).toBeVisible({ timeout: TIMEOUT });
+  });
+
+  test('non-existent placement id returns 400', async ({ page }) => {
+    const status = await postRaw(page, {
+      updates: [
+        { id: 999999999, priority: 1, solutionCategory: SolutionCategory.PENDING, taskGrade: null },
+      ],
+    });
+    expect(status).toBe(BAD_REQUEST);
+  });
+
+  test('invalid request body (missing required fields) returns 400', async ({ page }) => {
+    const status = await postRaw(page, { updates: [{ id: 1 }] });
+    expect(status).toBe(BAD_REQUEST);
+  });
+
+  test('invalid request body (wrong type for updates) returns 400', async ({ page }) => {
+    const status = await postRaw(page, { updates: 'not-an-array' });
+    expect(status).toBe(BAD_REQUEST);
+  });
+
+  test('CURRICULUM↔SOLUTION cross-type move returns 400', async ({ page }) => {
+    // Find a CURRICULUM placement from the board
+    await page.goto(`${ORDER_URL}?tab=curriculum&grades=${TaskGrade.Q10}`);
+    await expect(page.getByRole('heading', { name: '10Q' })).toBeVisible({ timeout: TIMEOUT });
+
+    const cards = await getCardsInColumn(page, TaskGrade.Q10);
+
+    if (cards.length === 0) {
+      test.skip();
+      return;
+    }
+
+    // Attempt to set solutionCategory on a CURRICULUM placement → should be rejected
+    const status = await postRaw(page, {
+      updates: [
+        {
+          id: cards[0].placementId,
+          priority: 1,
+          solutionCategory: SolutionCategory.PENDING,
+          taskGrade: null,
+        },
+      ],
+    });
+    expect(status).toBe(BAD_REQUEST);
+  });
+});
+
+// Helper functions
+async function loginAsAdmin(page: Page): Promise<void> {
+  const ADMIN_USERNAME = 'admin';
+  const ADMIN_PASSWORD = 'Ch0kuda1';
+
+  await page.goto('/login');
+  await expect(page).toHaveURL('/login', { timeout: TIMEOUT });
+  await page.locator('input[name="username"]').fill(ADMIN_USERNAME);
+  await page.locator('input[name="password"]').fill(ADMIN_PASSWORD);
+  await page.getByRole('button', { name: 'ログイン' }).nth(1).click();
+  await expect(page).toHaveURL('/', { timeout: TIMEOUT });
+}
+
+async function getCardsInColumn(
+  page: Page,
+  columnId: string,
+): Promise<{ title: string; placementId: number }[]> {
+  const cards = page.locator(`[data-testid="column-${columnId}"] [data-placement-id]`);
+  const count = await cards.count();
+  const result: { title: string; placementId: number }[] = [];
+
+  for (let i = 0; i < count; i++) {
+    const card = cards.nth(i);
+    const title = (await card.textContent()) ?? '';
+    const id = await card.getAttribute('data-placement-id');
+    result.push({ title: title.trim(), placementId: Number(id) });
+  }
+
+  return result;
+}
+
+async function postUpdates(
+  page: Page,
+  updates: {
+    id: number;
+    priority: number;
+    solutionCategory: SolutionCategory | null;
+    taskGrade: TaskGrade | null;
+  }[],
+): Promise<void> {
+  const status = await page.evaluate(
+    async ({ url, body }) => {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      return res.status;
+    },
+    { url: ORDER_URL, body: { updates } },
+  );
+  expect(status).toBe(OK);
+}
+
+async function postRaw(page: Page, body: unknown): Promise<number> {
+  return page.evaluate(
+    async ({ url, body }) => {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+
+      return response.status;
+    },
+    { url: ORDER_URL, body },
+  );
+}