diff --git a/.claude/rules/coding-style.md b/.claude/rules/coding-style.md
index 516d6b631..33ac38cae 100644
--- a/.claude/rules/coding-style.md
+++ b/.claude/rules/coding-style.md
@@ -27,15 +27,7 @@ Before writing new logic, decide which layer it belongs to. Run this check at pl
 - **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.
 - **Function verbs**: every function name must start with a verb. Noun-only names (`pointOnCircle`, `arcPath`) are ambiguous — use `calcPointOnCircle`, `buildArcPath`, etc. Common prefixes: `get` (read existing), `build`/`create` (construct new), `calc`/`compute` (derive by formula), `update`, `fetch`, `resolve`.
-- **`any`**: before using `any`, check the value's origin — adding a missing `@types/*` or `devDependency` often provides the correct type. When `any` seems unavoidable, use the narrowest alternative:
-
-  | Situation                                                  | Alternative                                                              |
-  | ---------------------------------------------------------- | ------------------------------------------------------------------------ |
-  | Assign to a property not on the type                       | `obj as T & { prop: U }` (intersection cast)                             |
-  | Return type too complex to write manually                  | `ReturnType<typeof fn>`                                                  |
-  | Partial mock: only specific properties matter              | `Partial<T>`, `Pick<T, 'a' \| 'b'>`, or `satisfies` — prefer these first |
-  | Partial mock: none of the above narrow the type far enough | `as unknown as T` — last resort; bypasses type checking entirely         |
-  | Inline `: any` annotation where inference reaches          | Delete the annotation                                                    |
+- **`any`**: Before using `any`, check the value's origin. If unavoidable: use `ReturnType<typeof fn>` for complex returns, `Partial<T>` for partial objects, `obj as T & { prop: U }` for property extension. Last resort: `as unknown as T`.
 
 - **UI labels**: if a label does not match actual behavior, update it or add an inline comment explaining the intentional mismatch.
 - **Constant names**: reflect what the value IS (content), not what it is used for (purpose). e.g., a set holding all enum tab values is `EXISTING_TABS`, not `VALID_TABS`.
@@ -50,25 +42,11 @@ Before writing new logic, decide which layer it belongs to. Run this check at pl
 - **Braces**: always use braces for single-statement `if` blocks. Never `if () return;` — write `if () { return; }`.
 - **Domain types over `string`**: when the Prisma schema uses an enum (e.g. `grade: TaskGrade`), the corresponding app-layer type must use the same enum — not `string`. A loose `string` type hides misspellings in fixtures and forces `as TaskGrade` casts throughout the codebase. When a field comes from an external source (form data, query params), validate and narrow it at the boundary; inside the app it must always be the domain type.
 - **Plural type aliases**: define `type Placements = Placement[]` instead of using `Placement[]` directly in signatures and variables.
-- **Empty `catch` blocks**: never use `catch { }` or `catch (_e)` to silence errors. Every `catch` must re-throw, log, or contain an explanatory comment justifying the suppression. Silent swallowing hides bugs and makes failures untraceable.
+- **Empty `catch` blocks**: never use `catch { }` to silence errors. Either re-throw, log, or add a comment justifying suppression. Silent swallowing hides bugs.
 
 ```typescript
-// Bad: silently discards the error
-try { ... } catch { }
-try { ... } catch (_e) { }
-
-// Good: log and re-throw (adds context before propagating)
-try { ... } catch (error) {
-  console.error('Operation failed:', error);
-  throw error;
-}
-
-// Good: intentional suppression with explanation
-try {
-  localStorage.setItem(key, value);
-} catch {
-  // localStorage may be unavailable (private browsing) — fall back to in-memory store
-}
+try { ... } catch (error) { console.error('...'); throw error; }  // good
+try { localStorage.setItem(key, value); } catch { /* unavailable */ }  // good + comment
 ```
 
 ### No Hard-Coded Values
@@ -101,60 +79,65 @@ Within a file, order declarations as follows:
 
 Place a private helper immediately after the single export that uses it. Place helpers shared by two or more exports at the end of the file.
 
-## Documentation
+### URL Parameter Patterns
 
-### Language Policy
-
-Write all project documentation (plans, dev-notes, guides, refactor notes) in Japanese. Write all source code comments, TSDoc, commit messages, and test titles in English. This keeps documentation readable for the team while keeping code comments universally accessible and searchable.
+#### null-as-ALL: Omitting Params for "All" State
 
-**Exception**: The `## CodeRabbit Findings` section in `plan.md` must quote findings verbatim in their original language (English). Do not translate CodeRabbit output.
+When a filter has an "all" or "unfiltered" state, omit the parameter entirely rather than using a magic value (e.g., "ALL", "\*").
 
-### TSDoc
+**Pattern:**
 
-Add TSDoc comments to every exported function, type, and class. The minimum required fields are `@param` (for non-obvious parameters) and `@returns` (when the return value is not evident from the type). One-liner `/** ... */` is sufficient for simple cases; use multi-line only when behavior needs explanation.
+- Parse function defaults to `null` when param is absent
+- `null` → "show all" (no filter applied)
+- URL: `/workbooks?tab=solution` (no `categories=`)
+- Browser back button naturally restores default "all" view
 
-For optional parameters with a default, state it explicitly in `@param`: `Defaults to false.`
+**Benefit:** Cleaner URLs, intuitive history behavior, smaller sessionStorage footprint.
 
-```typescript
-/** Returns the URL slug for a workbook, falling back to the workbook ID. */
-export function getUrlSlugFrom(workbook: WorkbookList): string { ... }
-```
+**Example:** `parseWorkBookCategory()` defaults to `null` = all categories
 
-### Markdown Code Blocks
+### Type Guards: Precise Narrowing for Excluded Values
 
-Always specify a language identifier on every fenced code block. Never write bare ` ``` `.
+When a type guard intentionally excludes enum members, use `Exclude<T, 'VALUE'>` in the return type to match runtime behavior. Caller code then trusts the type system; no `as` casts needed.
 
-Common identifiers: `typescript`, `svelte`, `sql`, `bash`, `mermaid`, `json`, `prisma`, `html`, `css`.
+### Layer-Specific Responsibility: Normalization vs Filtering
 
-### Svelte 5: Prefer Official Docs Over Training Knowledge
+When filtering data by multiple criteria (format + role):
 
-When Svelte 5 behavior is unclear, fetch official docs via WebFetch — do not rely on training knowledge. URL pattern: `https://svelte.dev/docs/svelte/{section}` (e.g. `/$effect`, `/stores`, `/what-are-runes`).
+- **Service layer**: Normalize raw data format (e.g., `null → PENDING`). Return all data; stay framework-agnostic and testable.
+- **UI layer**: Filter by role/context (e.g., "admin sees PENDING, user doesn't"). Apply display rules in component.
 
-## Security
+**Benefit**: Services remain pure and unit-testable without mocking roles; UI logic explicit in one place.
 
-### Server-side Logging
+### Function Composition: Single Responsibility
 
-Do not log user-identifiable or content data (titles, names, IDs that map to users) in server-side `console.log`. Use generic messages instead:
+Separate independent transformations into distinct functions. Compose at call site.
 
 ```typescript
-// Bad: leaks content and user identity
-console.log(`Created workbook "${workBook.title}" by user ${author.id}`);
-
-// Good
-console.log('Workbook created successfully');
+// groupBySolutionCategory(): pure grouping (testable)
+// filterGroupsByRole(): pure filtering by role (testable)
+let filtered = $derived(filterGroupsByRole(groupBySolutionCategory(workbooks, map), role));
 ```
 
-Prefer placing the single authoritative log in the service layer; remove duplicate logs in route handlers that cover the same event.
+**Benefit**: Each function testable in isolation; reusable in different contexts.
+
+## Documentation
+
+### Language Policy
+
+Write all project documentation (plans, dev-notes, guides, refactor notes) in Japanese. Write all source code comments, TSDoc, commit messages, and test titles in English. This keeps documentation readable for the team while keeping code comments universally accessible and searchable.
 
-## Code Review
+**Exception**: The `## CodeRabbit Findings` section in `plan.md` must quote findings verbatim in their original language (English). Do not translate CodeRabbit output.
+
+### TSDoc
 
-### CodeRabbit Review: Severity Triage
+Add TSDoc to every exported function, type, class. Minimum: `@param` (non-obvious), `@returns` (not evident from type). One-liner OK; multi-line for complex behavior only.
 
-Run `coderabbit review --plain` once after all phases are complete (not on every commit).
+### Documentation
 
-**Triage by severity:**
+Write plans/dev-notes/guides in Japanese. Source code comments in English. Always specify language on code blocks (e.g., `typescript`, `sql`, `bash`). For Svelte 5 unclear behavior: fetch official docs via WebFetch, not training knowledge.
 
-- **critical / high / potential_issue (medium)**: Write all findings verbatim to a `## CodeRabbit Findings` section in `plan.md`. The user decides which to fix before opening the PR. Do not fix any of these findings unilaterally.
-- **nitpick / info**: Defer to PR CI — CodeRabbit will re-comment on the open PR.
+## Security & Code Review
 
-Writing medium-and-above findings to `plan.md` serves a dual purpose: it gives the user full visibility for a fix/defer decision, and it builds the implementer's understanding of recurring quality issues.
+- **Logging**: No user-identifiable data in `console.log`. Single authoritative log in service layer.
+- **CodeRabbit**: Run after all phases complete. Write `critical`/`high`/`medium` findings to `plan.md` verbatim; defer `nitpick` to PR CI.
diff --git a/.claude/rules/testing-e2e.md b/.claude/rules/testing-e2e.md
index babeef13b..5347acea8 100644
--- a/.claude/rules/testing-e2e.md
+++ b/.claude/rules/testing-e2e.md
@@ -74,6 +74,26 @@ for (const grade of GRADES) {
 
 After an interaction that changes element state (active tab, toggle, selection), assert the _new_ state — not just that the element is visible, which may have been true before the interaction. Assert an active CSS class, `aria-selected`, or similar attribute instead of `toBeVisible()`.
 
+### Prefer Semantic Attributes Over CSS Classes
+
+Assert element state via accessibility attributes (`aria-pressed`, `aria-selected`, `data-*`), not CSS classes (which are implementation details and break on style refactors).
+
+**Bad:** Brittle to styling changes
+
+```typescript
+await expect(button).toHaveClass(/text-primary-700/);
+```
+
+**Good:** Resilient to refactors
+
+```typescript
+await expect(button).toHaveAttribute('aria-pressed', 'true');
+// or
+await expect(button).toHaveAttribute('data-active', 'true');
+```
+
+**Note:** If component library doesn't expose the attribute, add it (or contribute PR). Teaching tests brittle selectors is not sustainable.
+
 ## Flowbite Toggle
 
 Flowbite's `Toggle` renders an `sr-only` `<input type="checkbox">` inside a `<label>`. Clicking the input directly fails because the visual `<span>` sibling intercepts pointer events. Click the label wrapper instead:
diff --git a/.claude/rules/testing.md b/.claude/rules/testing.md
index 31cb044fc..3ceda46cc 100644
--- a/.claude/rules/testing.md
+++ b/.claude/rules/testing.md
@@ -26,22 +26,7 @@ If a task description does not mention tests, add them anyway for any non-trivia
 
 ## Unused Imports in Test Files
 
-An unused import in a test file is a signal that a test was planned but not yet written — not dead code to remove.
-
-Before deleting such an import, check whether the corresponding test case is missing and add it:
-
-```typescript
-// Bad: remove the import because it's unused
-import { ABCLikeProvider } from './contest_table_provider';
-
-// Good: the import is unused because the test is missing — add the test
-test('expects to create ABCLike preset correctly', () => {
-  const group = prepareContestProviderPresets().ABCLike();
-  expect(group.getProvider(ContestType.ABC_LIKE)).toBeInstanceOf(ABCLikeProvider);
-});
-```
-
-Removing the import silences the linter but leaves a coverage gap. Adding the test both satisfies the linter and improves coverage.
+Unused imports signal a missing test, not dead code. Before deleting, add the corresponding test case.
 
 ## Test Types
 
@@ -67,7 +52,24 @@ Test stub parameter types must match the production function's signature — use
 - 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
-- **Description ↔ code path alignment**: when a test name describes a specific scenario (e.g. "tie-break"), verify the fixture actually exercises that code path. A test that passes without reaching the branch it claims to cover gives false confidence
+- **Description ↔ code path alignment**: when a test name describes a specific scenario (e.g. "tie-break"), verify the fixture actually exercises that code path
+
+### Fixture Sharing in describe() Scope
+
+When multiple tests in a `describe` block use identical fixture data, define it once at block scope instead of duplicating in each test. Benefit: DRY + fixture changes sync automatically. Only use if fixture is immutable within tests (no mutations).
+
+```typescript
+describe('filterByRole', () => {
+  const testGroups = [{ role: ADMIN }, { role: PENDING }];
+
+  test('admin sees all', () => {
+    expect(filter(testGroups, ADMIN)).toHaveLength(2);
+  });
+  test('user sees filtered', () => {
+    expect(filter(testGroups, USER)).toHaveLength(1);
+  });
+});
+```
 
 ## Coverage
 
@@ -78,75 +80,31 @@ Test stub parameter types must match the production function's signature — use
 
 Order `describe` blocks in service and utils test files to match the declaration order of functions in the source file. Misalignment makes it harder to cross-reference tests and implementation.
 
+### Describe Block Organization: Multi-Scenario Functions
+
+Split `describe` blocks by scenario (not all cases flat) when a function behaves differently by mode. Example: separate `describe('func with modeA')` and `describe('func with modeB')` rather than mixing all cases. Benefit: better test discovery and names.
+
 ## Service Layer Unit Tests
 
 Service tests mock Prisma via `vi.mock('$lib/server/database', ...)` — no real DB mutations occur.
 
 ### Mock Helpers
 
-Extract repeated mock patterns into helpers in the test file. Define the return type alias once and use it across all helpers:
+Extract repeated mock patterns into helpers. Use `mockFindUnique`, `mockFindMany`, `mockCount` as the standard trio for Prisma model tests. Add `mockCreate`, `mockTransaction`, `mockDelete` when needed.
 
-```typescript
-type PrismaWorkBook = Awaited<ReturnType<typeof prisma.workBook.findUnique>>;
-type PrismaWorkBookRow = Awaited<ReturnType<typeof prisma.workBook.findMany>>[number];
-
-function mockFindUnique(value: PrismaWorkBook) {
-  vi.mocked(prisma.workBook.findUnique).mockResolvedValue(value);
-}
-
-function mockFindMany(value: PrismaWorkBookRow[]) {
-  vi.mocked(prisma.workBook.findMany).mockResolvedValue(
-    value as unknown as Awaited<ReturnType<typeof prisma.workBook.findMany>>,
-  );
-}
-
-function mockCount(value: number) {
-  vi.mocked(prisma.workBook.count).mockResolvedValue(value);
-}
-```
-
-Extract `mockFindUnique`, `mockFindMany`, and `mockCount` as the standard trio for service tests that touch a single Prisma model. Add `mockCreate`, `mockTransaction`, and `mockDelete` when those operations are also tested.
-
-### Cleanup for Integration Tests and Tests with Real Side Effects
+### Cleanup for Integration Tests
 
-This does not apply to standard service layer unit tests that use Prisma mocks.
-
-If a test performs real DB mutations, file system changes, external API calls, or other stateful side effects that persist beyond the test (e.g., integration tests, seed scripts), wrap assertions in `try/finally` — a failing assertion skips cleanup and contaminates later tests:
-
-```typescript
-try {
-  await doSomething();
-  expect(result).toBe(expected);
-} finally {
-  await restoreState();
-}
-```
+For tests with real side effects (DB mutations, file changes, API calls), wrap assertions in `try/finally` — a failing assertion skips cleanup and contaminates later tests.
 
 ### File 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.
-
-## Component Vitest Unit Tests
-
-E2E tests are complementary to, not a substitute for, unit tests. Add Vitest unit tests for any component logic (derived values, event handlers, utility calls) by extracting it to the nearest `utils/` file and testing there.
-
-You may omit a component-level Vitest test when **both** conditions hold:
-
-1. The component is template-only (no logic beyond prop bindings and simple `{#if}`/`{#each}` blocks that only render — no inline function calls, ternaries with side effects, derived computations, or nested logic)
-2. The component's rendering paths are covered by E2E tests
-
-When a component contains extracted logic (e.g. derived values, event handlers, utility calls), add unit tests for that logic in the nearest `utils/` file instead of testing the component directly.
+When a service mixes DB operations and pure functions, split into `crud.ts` (DB; Prisma mocks needed) and `initializers.ts` (pure; no mocks). Skip split if cohesion suffers.
 
-## Testing Extracted Utilities
+## Component & Utility Tests
 
-- 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
+- Extract component logic to `utils/` and test there, not in the component.
+- Omit component Vitest test if template-only **and** E2E tests cover rendering paths.
+- Add utility tests at extraction time; assert immutability (URLs) and all affected parts (multi-column operations).
 
 ## HTTP Mocking
 
diff --git a/e2e/workbooks_list.spec.ts b/e2e/workbooks_list.spec.ts
index af66ef1a0..45de0310b 100644
--- a/e2e/workbooks_list.spec.ts
+++ b/e2e/workbooks_list.spec.ts
@@ -17,6 +17,9 @@ const GRADE_Q10 = 'Q10';
 const GRADE_Q9 = 'Q9';
 const GRADE_Q8 = 'Q8';
 
+// All button label
+const LABEL_ALL = 'All';
+
 // Category URL parameter values (must match SolutionCategory in src/features/workbooks/types/workbook_placement.ts)
 const CATEGORY_GRAPH = 'GRAPH';
 const CATEGORY_DP = 'DYNAMIC_PROGRAMMING';
@@ -143,6 +146,56 @@ test.describe('logged-in user (general)', () => {
         await expect(page).toHaveURL(new RegExp(`categories=${category}`), { timeout: TIMEOUT });
       });
     }
+
+    test.describe('solution tab all-categories view', () => {
+      test('solution tab default shows All button as active', async ({ page }) => {
+        await page.goto(`${WORKBOOK_LIST_URL}?tab=${TAB_SOLUTION}`);
+        await expect(page.getByRole('tab', { name: '解法別' })).toHaveAttribute(
+          'aria-selected',
+          'true',
+          { timeout: TIMEOUT },
+        );
+
+        const allButton = page.getByRole('button', { name: LABEL_ALL });
+        await expect(allButton).toBeVisible({ timeout: TIMEOUT });
+        // Verify All button is marked as active via semantic attribute
+        await expect(allButton).toHaveAttribute('aria-pressed', 'true', { timeout: TIMEOUT });
+      });
+
+      test('All button is shown at the beginning of category buttons', async ({ page }) => {
+        await page.goto(`${WORKBOOK_LIST_URL}?tab=${TAB_SOLUTION}`);
+        await expect(page.getByRole('tab', { name: '解法別' })).toBeVisible({ timeout: TIMEOUT });
+
+        // Scope to the category buttons container to find the first button in that section
+        const categoryButtonsContainer = page.locator('div.mb-6');
+        const firstButton = categoryButtonsContainer.getByRole('button').first();
+        await expect(firstButton).toHaveText(LABEL_ALL, { timeout: TIMEOUT });
+      });
+
+      test('clicking All button shows category-grouped sections', async ({ page }) => {
+        // First, open with a specific category
+        await page.goto(`${WORKBOOK_LIST_URL}?tab=${TAB_SOLUTION}&categories=${CATEGORY_GRAPH}`);
+        await expect(page.getByRole('tab', { name: '解法別' })).toBeVisible({ timeout: TIMEOUT });
+
+        // Click the All button
+        await page.getByRole('button', { name: LABEL_ALL }).click();
+        await expect(page).toHaveURL(new RegExp(`tab=${TAB_SOLUTION}`), { timeout: TIMEOUT });
+        // Verify that the categories= parameter is not in the URL
+        await expect(page).not.toHaveURL(/categories=/, { timeout: TIMEOUT });
+
+        // Verify category sections render
+        await expect(page.getByRole('heading', { name: 'グラフ' })).toBeVisible({
+          timeout: TIMEOUT,
+        });
+      });
+
+      test('non-admin user does not see PENDING section in All view', async ({ page }) => {
+        await page.goto(`${WORKBOOK_LIST_URL}?tab=${TAB_SOLUTION}`);
+        await expect(page.getByRole('tab', { name: '解法別' })).toBeVisible({ timeout: TIMEOUT });
+
+        await expect(page.getByRole('heading', { name: '未分類' })).not.toBeVisible();
+      });
+    });
   });
 
   test.describe('session state', () => {
@@ -230,6 +283,27 @@ test.describe('admin user', () => {
     });
   });
 
+  test.describe('solution tab all-categories view (admin)', () => {
+    test('admin sees PENDING section in All view when PENDING workbooks exist', async ({
+      page,
+    }) => {
+      await page.goto(`${WORKBOOK_LIST_URL}?tab=${TAB_SOLUTION}`);
+      await expect(page.getByRole('tab', { name: '解法別' })).toBeVisible({ timeout: TIMEOUT });
+
+      const pendingHeading = page.getByRole('heading', { name: '未分類' });
+
+      if (
+        !(await pendingHeading.isVisible({ timeout: VISIBILITY_CHECK_TIMEOUT }).catch(() => false))
+      ) {
+        // PENDING 問題集が存在しない場合はスキップ
+        test.skip();
+        return;
+      }
+
+      await expect(pendingHeading).toBeVisible({ timeout: TIMEOUT });
+    });
+  });
+
   test.describe('workbook actions', () => {
     test('workbook rows show edit link and delete button', async ({ page }) => {
       await page.goto(WORKBOOK_LIST_URL);
diff --git a/lefthook.yml b/lefthook.yml
index 0eb723864..7009dea10 100644
--- a/lefthook.yml
+++ b/lefthook.yml
@@ -14,3 +14,11 @@ pre-commit:
     - name: eslint
       run: pnpm exec eslint {staged_files}
       glob: '**/*.svelte'
+
+    - name: plan-lambda-check
+      run: >
+        if grep -nE '\([a-z]\)\s*(=>|:)' -- {staged_files}; then
+          echo "Error: single-char lambda/type parameters found in plan code blocks. Rename to full domain concept (workbook, placement, group, ...)";
+          exit 1;
+        fi
+      glob: 'docs/**/*.md'
diff --git a/src/features/workbooks/components/list/SolutionWorkBookList.svelte b/src/features/workbooks/components/list/SolutionWorkBookList.svelte
index 6b03e48ae..f4ee2ba96 100644
--- a/src/features/workbooks/components/list/SolutionWorkBookList.svelte
+++ b/src/features/workbooks/components/list/SolutionWorkBookList.svelte
@@ -8,9 +8,16 @@
     SolutionCategory,
     type SolutionCategories,
     SOLUTION_LABELS,
+    ALL_SOLUTION_CATEGORIES,
+    type SelectedSolutionCategory,
   } from '$features/workbooks/types/workbook_placement';
 
   import { countReadableWorkbooks } from '$features/workbooks/utils/workbooks';
+  import {
+    groupBySolutionCategory,
+    filterGroupsByRole,
+    type WorkbookGroup,
+  } from '$features/workbooks/utils/solution_category_group';
 
   import SolutionTable from '$features/workbooks/components/list/SolutionTable.svelte';
   import EmptyWorkbookList from '$features/workbooks/components/list/EmptyWorkbookList.svelte';
@@ -21,8 +28,9 @@
     userId: string;
     role: Roles;
     availableCategories: SolutionCategories;
-    currentCategory: SolutionCategory;
-    onCategoryChange: (category: SolutionCategory) => void;
+    currentCategory: SelectedSolutionCategory;
+    solutionCategoryMap: Map<number, SolutionCategory>;
+    onCategoryChange: (category: SelectedSolutionCategory) => void;
   }
 
   let {
@@ -32,6 +40,7 @@
     role,
     availableCategories,
     currentCategory,
+    solutionCategoryMap,
     onCategoryChange,
   }: Props = $props();
 
@@ -43,23 +52,68 @@
     ),
   );
 
+  // Unified button entries: All (null) first, then individual categories.
+  // Using a typed entry object avoids a separate ALL button in the template.
+  type CategoryEntry = { value: SelectedSolutionCategory; label: string };
+
+  const ALL_ENTRY: CategoryEntry = { value: ALL_SOLUTION_CATEGORIES, label: 'All' };
+
+  let CATEGORY_ENTRIES = $derived<CategoryEntry[]>([
+    ALL_ENTRY,
+    ...AVAILABLE_CATEGORIES.map(
+      (category): CategoryEntry => ({
+        value: category,
+        label: SOLUTION_LABELS[category],
+      }),
+    ),
+  ]);
+
+  // "全て" 選択時のグループ化。特定カテゴリ選択時は null。
+  let groupedWorkbooks = $derived<WorkbookGroup[] | null>(
+    currentCategory === ALL_SOLUTION_CATEGORIES
+      ? filterGroupsByRole(groupBySolutionCategory(workbooks, solutionCategoryMap), role)
+      : null,
+  );
+
   let readableCount = $derived(countReadableWorkbooks(workbooks, userId));
 </script>
 
 <div class="mb-6 flex flex-wrap gap-1">
-  {#each AVAILABLE_CATEGORIES as category (category)}
+  {#each CATEGORY_ENTRIES as entry (entry.value ?? 'all')}
     <Button
-      onclick={() => onCategoryChange(category)}
+      onclick={() => onCategoryChange(entry.value)}
       color="alternative"
-      class={`rounded-lg dark:text-white ${currentCategory === category ? 'text-primary-700 dark:text-primary-500!' : ''}`}
+      aria-pressed={currentCategory === entry.value}
+      class={`rounded-lg dark:text-white ${currentCategory === entry.value ? 'text-primary-700 dark:text-primary-500!' : ''}`}
     >
-      {SOLUTION_LABELS[category]}
+      {entry.label}
     </Button>
   {/each}
 </div>
 
-{#if readableCount}
-  <SolutionTable {workbooks} {userId} {role} taskResults={taskResultsWithWorkBookId} />
+{#if currentCategory === ALL_SOLUTION_CATEGORIES}
+  <!-- Group display: render sections in SolutionCategory enum order -->
+  {#if readableCount}
+    {#each groupedWorkbooks ?? [] as group, i (group.category)}
+      <div class={i > 0 ? 'mt-8' : ''}>
+        <h2 class="text-2xl pb-4 dark:text-white">{SOLUTION_LABELS[group.category]}</h2>
+        <SolutionTable
+          workbooks={group.workbooks}
+          {userId}
+          {role}
+          taskResults={taskResultsWithWorkBookId}
+        />
+      </div>
+    {/each}
+  {:else}
+    <EmptyWorkbookList />
+  {/if}
 {:else}
-  <EmptyWorkbookList />
+  <!-- Specific category selected: flat list display with category title -->
+  {#if readableCount}
+    <h2 class="text-2xl pb-4 dark:text-white">{SOLUTION_LABELS[currentCategory]}</h2>
+    <SolutionTable {workbooks} {userId} {role} taskResults={taskResultsWithWorkBookId} />
+  {:else}
+    <EmptyWorkbookList />
+  {/if}
 {/if}
diff --git a/src/features/workbooks/components/list/WorkBookList.svelte b/src/features/workbooks/components/list/WorkBookList.svelte
index 184f86187..4a2410756 100644
--- a/src/features/workbooks/components/list/WorkBookList.svelte
+++ b/src/features/workbooks/components/list/WorkBookList.svelte
@@ -5,6 +5,7 @@
   import {
     type SolutionCategory,
     type SolutionCategories,
+    type SelectedSolutionCategory,
   } from '$features/workbooks/types/workbook_placement';
 
   import CurriculumWorkBookList from '$features/workbooks/components/list/CurriculumWorkBookList.svelte';
@@ -26,9 +27,10 @@
       }
     | {
         workbookType: typeof WorkBookType.SOLUTION;
-        currentCategory: SolutionCategory;
+        currentCategory: SelectedSolutionCategory;
         availableCategories: SolutionCategories;
-        onCategoryChange: (category: SolutionCategory) => void;
+        solutionCategoryMap: Map<number, SolutionCategory>;
+        onCategoryChange: (category: SelectedSolutionCategory) => void;
       }
     | { workbookType: typeof WorkBookType.CREATED_BY_USER };
 
@@ -56,6 +58,7 @@
     role={loggedInUser?.role ?? Roles.USER}
     availableCategories={restProps.availableCategories}
     currentCategory={restProps.currentCategory}
+    solutionCategoryMap={restProps.solutionCategoryMap}
     onCategoryChange={restProps.onCategoryChange}
   />
 {:else}
diff --git a/src/features/workbooks/services/workbooks.test.ts b/src/features/workbooks/services/workbooks.test.ts
index ee65b7c36..fe110f3ee 100644
--- a/src/features/workbooks/services/workbooks.test.ts
+++ b/src/features/workbooks/services/workbooks.test.ts
@@ -10,6 +10,7 @@ import {
   getWorkbooksByPlacement,
   getWorkBooksCreatedByUsers,
   getAvailableSolutionCategories,
+  getSolutionCategoryMapByWorkbookId,
 } from './workbooks';
 import { TaskGrade } from '$lib/types/task';
 import { WorkBookType, type WorkBook } from '$features/workbooks/types/workbook';
@@ -222,6 +223,41 @@ describe('getWorkbooksByPlacement', () => {
 
     expect(result[0].authorName).toBe('unknown');
   });
+
+  test('returns all SOLUTION workbooks when solutionCategory is null', async () => {
+    mockFindMany([
+      { ...MOCK_WORKBOOK_BASE, workBookType: WorkBookType.SOLUTION },
+      { ...MOCK_WORKBOOK_BASE, id: 2, workBookType: WorkBookType.SOLUTION },
+    ]);
+
+    await getWorkbooksByPlacement({
+      workBookType: WorkBookType.SOLUTION,
+      solutionCategory: null,
+    });
+
+    expect(prisma.workBook.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          workBookType: WorkBookType.SOLUTION,
+          isPublished: true,
+          placement: {}, // no solutionCategory filter
+        }),
+      }),
+    );
+  });
+
+  test('null solutionCategory with includeUnpublished=true omits isPublished filter', async () => {
+    mockFindMany([{ ...MOCK_WORKBOOK_BASE, workBookType: WorkBookType.SOLUTION }]);
+
+    await getWorkbooksByPlacement(
+      { workBookType: WorkBookType.SOLUTION, solutionCategory: null },
+      true,
+    );
+
+    const callArg = vi.mocked(prisma.workBook.findMany).mock.calls[0][0];
+    expect(callArg?.where).not.toHaveProperty('isPublished');
+    expect(callArg?.where?.placement).toEqual({});
+  });
 });
 
 describe('getWorkBooksCreatedByUsers', () => {
@@ -308,6 +344,64 @@ describe('getAvailableSolutionCategories', () => {
   });
 });
 
+describe('getSolutionCategoryMapByWorkbookId', () => {
+  test('returns a Map of workbookId to SolutionCategory for published workbooks', async () => {
+    vi.mocked(prisma.workBookPlacement.findMany).mockResolvedValue([
+      { workBookId: 1, solutionCategory: SolutionCategory.GRAPH },
+      { workBookId: 2, solutionCategory: SolutionCategory.DYNAMIC_PROGRAMMING },
+    ] as unknown as Awaited<ReturnType<typeof prisma.workBookPlacement.findMany>>);
+
+    const result = await getSolutionCategoryMapByWorkbookId(false);
+
+    expect(prisma.workBookPlacement.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          workBook: expect.objectContaining({
+            workBookType: WorkBookType.SOLUTION,
+            isPublished: true,
+          }),
+        }),
+        select: { workBookId: true, solutionCategory: true },
+      }),
+    );
+    expect(result.get(1)).toBe(SolutionCategory.GRAPH);
+    expect(result.get(2)).toBe(SolutionCategory.DYNAMIC_PROGRAMMING);
+  });
+
+  test('normalizes null solutionCategory to PENDING', async () => {
+    vi.mocked(prisma.workBookPlacement.findMany).mockResolvedValue([
+      { workBookId: 1, solutionCategory: null },
+      { workBookId: 2, solutionCategory: SolutionCategory.GRAPH },
+    ] as unknown as Awaited<ReturnType<typeof prisma.workBookPlacement.findMany>>);
+
+    const result = await getSolutionCategoryMapByWorkbookId(false);
+
+    expect(result.get(1)).toBe(SolutionCategory.PENDING);
+    expect(result.get(2)).toBe(SolutionCategory.GRAPH);
+  });
+
+  test('omits isPublished filter when includeUnpublished=true', async () => {
+    vi.mocked(prisma.workBookPlacement.findMany).mockResolvedValue(
+      [] as unknown as Awaited<ReturnType<typeof prisma.workBookPlacement.findMany>>,
+    );
+
+    await getSolutionCategoryMapByWorkbookId(true);
+
+    const callArg = vi.mocked(prisma.workBookPlacement.findMany).mock.calls[0][0];
+    expect(callArg?.where?.workBook).not.toHaveProperty('isPublished');
+  });
+
+  test('returns empty Map when no placements exist', async () => {
+    vi.mocked(prisma.workBookPlacement.findMany).mockResolvedValue(
+      [] as unknown as Awaited<ReturnType<typeof prisma.workBookPlacement.findMany>>,
+    );
+
+    const result = await getSolutionCategoryMapByWorkbookId(false);
+
+    expect(result.size).toBe(0);
+  });
+});
+
 describe('getWorkBook', () => {
   test('returns workbook when found', async () => {
     const workBook = prepareWorkBook({ id: 42 });
diff --git a/src/features/workbooks/services/workbooks.ts b/src/features/workbooks/services/workbooks.ts
index 191aa159c..d3c056cbc 100644
--- a/src/features/workbooks/services/workbooks.ts
+++ b/src/features/workbooks/services/workbooks.ts
@@ -12,6 +12,7 @@ import {
   type PlacementQuery,
   SolutionCategory,
   type SolutionCategories,
+  ALL_SOLUTION_CATEGORIES,
 } from '$features/workbooks/types/workbook_placement';
 
 import {
@@ -71,10 +72,7 @@ export async function getWorkbooksByPlacement(
   query: PlacementQuery,
   includeUnpublished = false,
 ): Promise<WorkbooksWithAuthors> {
-  const placementFilter =
-    query.workBookType === WorkBookTypeConst.CURRICULUM
-      ? { taskGrade: query.taskGrade }
-      : { solutionCategory: query.solutionCategory };
+  const placementFilter = buildPlacementFilter(query);
 
   const workbooks = await db.workBook.findMany({
     where: {
@@ -145,6 +143,33 @@ export async function getAvailableSolutionCategories(
     .filter((category): category is SolutionCategory => category !== null);
 }
 
+/**
+ * Returns a Map of workbook ID to SolutionCategory for all SOLUTION workbooks with a placement.
+ * Used to group workbooks by category when the "all categories" view is selected.
+ *
+ * @param includeUnpublished - When true, includes unpublished workbooks (admin use). Defaults to false.
+ */
+export async function getSolutionCategoryMapByWorkbookId(
+  includeUnpublished = false,
+): Promise<Map<number, SolutionCategory>> {
+  const placements = await db.workBookPlacement.findMany({
+    where: {
+      workBook: {
+        workBookType: WorkBookTypeConst.SOLUTION,
+        ...(includeUnpublished ? {} : { isPublished: true }),
+      },
+    },
+    select: { workBookId: true, solutionCategory: true },
+  });
+
+  const categoryEntries = placements.map((placement): [number, SolutionCategory] => [
+    placement.workBookId,
+    placement.solutionCategory ?? SolutionCategory.PENDING,
+  ]);
+
+  return new Map(categoryEntries);
+}
+
 export async function getWorkBook(workBookId: number): Promise<WorkBook | null> {
   const workBook = await db.workBook.findUnique({
     where: {
@@ -310,3 +335,16 @@ function mapWithAuthorName<T extends { user: { username: string } | null }>(
     authorName: workbook.user?.username ?? 'unknown',
   }));
 }
+
+/** Returns the Prisma placement where-filter for a given PlacementQuery. */
+function buildPlacementFilter(query: PlacementQuery) {
+  if (query.workBookType === WorkBookTypeConst.CURRICULUM) {
+    return { taskGrade: query.taskGrade };
+  }
+
+  if (query.solutionCategory === ALL_SOLUTION_CATEGORIES) {
+    return {}; // no solutionCategory filter = fetch all solution categories
+  }
+
+  return { solutionCategory: query.solutionCategory };
+}
diff --git a/src/features/workbooks/types/workbook_placement.ts b/src/features/workbooks/types/workbook_placement.ts
index 210825148..76bd11e11 100644
--- a/src/features/workbooks/types/workbook_placement.ts
+++ b/src/features/workbooks/types/workbook_placement.ts
@@ -91,13 +91,19 @@ export type UnplacedCurriculumRow = {
 
 export type UnplacedCurriculumRows = UnplacedCurriculumRow[];
 
+/** Sentinel value representing "all solution categories" (no solutionCategory filter). Runtime value is null. */
+export const ALL_SOLUTION_CATEGORIES = null;
+
+/** Category selection for the SOLUTION tab. null means "show all categories". */
+export type SelectedSolutionCategory = SolutionCategory | null;
+
 /**
  * Discriminated union representing a placement-based filter query.
  * CURRICULUM filters by taskGrade; SOLUTION filters by solutionCategory.
  */
 export type PlacementQuery =
   | { workBookType: typeof WorkBookTypeConst.CURRICULUM; taskGrade: TaskGrade }
-  | { workBookType: typeof WorkBookTypeConst.SOLUTION; solutionCategory: SolutionCategory };
+  | { workBookType: typeof WorkBookTypeConst.SOLUTION; solutionCategory: SelectedSolutionCategory };
 
 // Shape of workbooks returned from the load function for use in KanbanBoard
 export type WorkbookWithPlacement = {
diff --git a/src/features/workbooks/utils/solution_category_group.test.ts b/src/features/workbooks/utils/solution_category_group.test.ts
new file mode 100644
index 000000000..93a0d5c0c
--- /dev/null
+++ b/src/features/workbooks/utils/solution_category_group.test.ts
@@ -0,0 +1,153 @@
+import { describe, test, expect } from 'vitest';
+import { Roles } from '$lib/types/user';
+import { SolutionCategory } from '$features/workbooks/types/workbook_placement';
+import type { WorkbooksList } from '$features/workbooks/types/workbook';
+import { groupBySolutionCategory, filterGroupsByRole } from './solution_category_group';
+
+// groupBySolutionCategory references only the workbook id, so minimal fixtures are sufficient.
+// Titles are aligned with actual workbook names to ensure readability.
+const GRAPH_WORKBOOK = {
+  id: 1,
+  title: 'ポテンシャル付き Union-Find',
+} as unknown as WorkbooksList[number];
+const DYNAMIC_PROGRAMMING_WORKBOOK_1 = {
+  id: 2,
+  title: '動的計画法（ナップサック問題）',
+} as unknown as WorkbooksList[number];
+const DYNAMIC_PROGRAMMING_WORKBOOK_2 = {
+  id: 3,
+  title: '動的計画法（区間 DP）',
+} as unknown as WorkbooksList[number];
+const PENDING_WORKBOOK = {
+  id: 4,
+  title: '数え上げ・確率（分類中）',
+} as unknown as WorkbooksList[number];
+
+function buildCategoryMap(entries: [number, SolutionCategory][]): Map<number, SolutionCategory> {
+  return new Map(entries);
+}
+
+describe('groupBySolutionCategory', () => {
+  test('groups workbooks by their SolutionCategory', () => {
+    const workbooks = [
+      GRAPH_WORKBOOK,
+      DYNAMIC_PROGRAMMING_WORKBOOK_1,
+      DYNAMIC_PROGRAMMING_WORKBOOK_2,
+    ];
+    const categoryMap = buildCategoryMap([
+      [1, SolutionCategory.GRAPH],
+      [2, SolutionCategory.DYNAMIC_PROGRAMMING],
+      [3, SolutionCategory.DYNAMIC_PROGRAMMING],
+    ]);
+
+    const result = groupBySolutionCategory(workbooks, categoryMap);
+
+    const graphGroup = result.find((group) => group.category === SolutionCategory.GRAPH);
+    const dynamicProgrammingGroup = result.find(
+      (group) => group.category === SolutionCategory.DYNAMIC_PROGRAMMING,
+    );
+
+    expect(graphGroup?.workbooks).toEqual([GRAPH_WORKBOOK]);
+    expect(dynamicProgrammingGroup?.workbooks).toEqual([
+      DYNAMIC_PROGRAMMING_WORKBOOK_1,
+      DYNAMIC_PROGRAMMING_WORKBOOK_2,
+    ]);
+  });
+
+  test('returns groups in SolutionCategory enum definition order', () => {
+    const workbooks = [GRAPH_WORKBOOK, DYNAMIC_PROGRAMMING_WORKBOOK_1];
+    const categoryMap = buildCategoryMap([
+      [1, SolutionCategory.GRAPH],
+      [2, SolutionCategory.DYNAMIC_PROGRAMMING],
+    ]);
+
+    const result = groupBySolutionCategory(workbooks, categoryMap);
+    const categories = result.map((group) => group.category);
+
+    const dynamicProgrammingIndex = Object.values(SolutionCategory).indexOf(
+      SolutionCategory.DYNAMIC_PROGRAMMING,
+    );
+    const graphIndex = Object.values(SolutionCategory).indexOf(SolutionCategory.GRAPH);
+    expect(categories.indexOf(SolutionCategory.DYNAMIC_PROGRAMMING)).toBeLessThan(
+      categories.indexOf(SolutionCategory.GRAPH),
+    );
+    expect(dynamicProgrammingIndex).toBeLessThan(graphIndex);
+  });
+
+  test('excludes empty groups from the result', () => {
+    const workbooks = [GRAPH_WORKBOOK];
+    const categoryMap = buildCategoryMap([[1, SolutionCategory.GRAPH]]);
+
+    const result = groupBySolutionCategory(workbooks, categoryMap);
+    expect(result.every((group) => group.workbooks.length > 0)).toBe(true);
+    expect(result.length).toBe(1);
+  });
+
+  test('includes PENDING group when PENDING workbooks are present', () => {
+    const workbooks = [PENDING_WORKBOOK];
+    const categoryMap = buildCategoryMap([[4, SolutionCategory.PENDING]]);
+
+    const result = groupBySolutionCategory(workbooks, categoryMap);
+    expect(result.find((group) => group.category === SolutionCategory.PENDING)).toBeDefined();
+  });
+
+  test('returns empty array when workbooks list is empty', () => {
+    const result = groupBySolutionCategory([], new Map());
+    expect(result).toEqual([]);
+  });
+
+  test('preserves workbook order within each group', () => {
+    const workbooks = [DYNAMIC_PROGRAMMING_WORKBOOK_1, DYNAMIC_PROGRAMMING_WORKBOOK_2];
+    const categoryMap = buildCategoryMap([
+      [2, SolutionCategory.DYNAMIC_PROGRAMMING],
+      [3, SolutionCategory.DYNAMIC_PROGRAMMING],
+    ]);
+
+    const result = groupBySolutionCategory(workbooks, categoryMap);
+    const dynamicProgrammingGroup = result.find(
+      (group) => group.category === SolutionCategory.DYNAMIC_PROGRAMMING,
+    );
+
+    expect(dynamicProgrammingGroup?.workbooks).toEqual([
+      DYNAMIC_PROGRAMMING_WORKBOOK_1,
+      DYNAMIC_PROGRAMMING_WORKBOOK_2,
+    ]);
+  });
+});
+
+describe('filterGroupsByRole', () => {
+  const testGroups = [
+    {
+      category: SolutionCategory.GRAPH,
+      workbooks: [GRAPH_WORKBOOK],
+    },
+    {
+      category: SolutionCategory.PENDING,
+      workbooks: [PENDING_WORKBOOK],
+    },
+  ];
+
+  test('returns all groups for admin users', () => {
+    const result = filterGroupsByRole(testGroups, Roles.ADMIN);
+
+    // Verify both groups (GRAPH + PENDING) are returned unchanged
+    expect(result).toHaveLength(2);
+    expect(result).toEqual(testGroups);
+  });
+
+  test('excludes PENDING group for non-admin users', () => {
+    const result = filterGroupsByRole(testGroups, Roles.USER);
+
+    // PENDING group is filtered out, only GRAPH group remains
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({
+      category: SolutionCategory.GRAPH,
+      workbooks: [GRAPH_WORKBOOK],
+    });
+  });
+
+  test('returns empty array when input is empty', () => {
+    const result = filterGroupsByRole([], Roles.USER);
+    expect(result).toEqual([]);
+  });
+});
diff --git a/src/features/workbooks/utils/solution_category_group.ts b/src/features/workbooks/utils/solution_category_group.ts
new file mode 100644
index 000000000..55da2f95f
--- /dev/null
+++ b/src/features/workbooks/utils/solution_category_group.ts
@@ -0,0 +1,44 @@
+import { Roles } from '$lib/types/user';
+import type { WorkbooksList } from '$features/workbooks/types/workbook';
+import { SolutionCategory } from '$features/workbooks/types/workbook_placement';
+
+export type WorkbookGroup = {
+  category: SolutionCategory;
+  workbooks: WorkbooksList;
+};
+
+export type WorkbookGroups = WorkbookGroup[];
+
+/**
+ * Groups workbooks by SolutionCategory in enum definition order.
+ * Empty groups are excluded from the result.
+ *
+ * @param workbooks - Flat list of solution workbooks
+ * @param categoryMap - Maps workbook ID to its SolutionCategory
+ */
+export function groupBySolutionCategory(
+  workbooks: WorkbooksList,
+  categoryMap: Map<number, SolutionCategory>,
+): WorkbookGroups {
+  return Object.values(SolutionCategory)
+    .map((category) => ({
+      category,
+      workbooks: workbooks.filter((workbook) => categoryMap.get(workbook.id) === category),
+    }))
+    .filter((group) => group.workbooks.length > 0);
+}
+
+/**
+ * Filters workbook groups based on user role.
+ * Non-admin users do not see PENDING (unclassified) groups.
+ *
+ * @param groups - List of workbook groups
+ * @param role - User role
+ */
+export function filterGroupsByRole(groups: WorkbookGroups, role: Roles): WorkbookGroups {
+  if (role === Roles.ADMIN) {
+    return groups;
+  }
+
+  return groups.filter((group) => group.category !== SolutionCategory.PENDING);
+}
diff --git a/src/features/workbooks/utils/workbook_url_params.test.ts b/src/features/workbooks/utils/workbook_url_params.test.ts
index d69c1ee87..69c2845fd 100644
--- a/src/features/workbooks/utils/workbook_url_params.test.ts
+++ b/src/features/workbooks/utils/workbook_url_params.test.ts
@@ -15,6 +15,10 @@ function toParams(query: string): URLSearchParams {
 }
 
 describe('parseWorkBookTab', () => {
+  test('returns curriculum (default) when tab is absent', () => {
+    expect(parseWorkBookTab(toParams(''))).toBe(WorkBookTab.CURRICULUM);
+  });
+
   test('returns curriculum for tab=curriculum', () => {
     expect(parseWorkBookTab(toParams('tab=curriculum'))).toBe(WorkBookTab.CURRICULUM);
   });
@@ -27,10 +31,6 @@ describe('parseWorkBookTab', () => {
     expect(parseWorkBookTab(toParams('tab=created_by_user'))).toBe(WorkBookTab.CREATED_BY_USER);
   });
 
-  test('returns curriculum (default) when tab is absent', () => {
-    expect(parseWorkBookTab(toParams(''))).toBe(WorkBookTab.CURRICULUM);
-  });
-
   test('returns curriculum (default) for invalid tab value', () => {
     expect(parseWorkBookTab(toParams('tab=invalid'))).toBe(WorkBookTab.CURRICULUM);
   });
@@ -93,41 +93,49 @@ describe('parseWorkBookCategory', () => {
     );
   });
 
-  test('returns SEARCH_SIMULATION (default) when categories is absent', () => {
-    expect(parseWorkBookCategory(toParams(''))).toBe(SolutionCategory.SEARCH_SIMULATION);
+  test('returns null (all categories) when categories is absent', () => {
+    expect(parseWorkBookCategory(toParams(''))).toBeNull();
   });
 
-  test('returns SEARCH_SIMULATION (default) for PENDING', () => {
-    expect(parseWorkBookCategory(toParams('categories=PENDING'))).toBe(
-      SolutionCategory.SEARCH_SIMULATION,
-    );
+  test('returns null (all categories) for PENDING', () => {
+    expect(parseWorkBookCategory(toParams('categories=PENDING'))).toBeNull();
   });
 
-  test('returns SEARCH_SIMULATION (default) for invalid value', () => {
-    expect(parseWorkBookCategory(toParams('categories=FLYING_FISH'))).toBe(
-      SolutionCategory.SEARCH_SIMULATION,
-    );
+  test('returns null (all categories) for invalid value', () => {
+    expect(parseWorkBookCategory(toParams('categories=FLYING_FISH'))).toBeNull();
   });
 });
 
 describe('buildWorkbooksUrl', () => {
-  test('curriculum tab with grade produces correct URL', () => {
-    expect(buildWorkbooksUrl(WorkBookTab.CURRICULUM, TaskGrade.Q9)).toBe(
-      '/workbooks?tab=curriculum&grades=Q9',
-    );
-  });
-
-  test('solution tab with category produces correct URL', () => {
-    expect(buildWorkbooksUrl(WorkBookTab.SOLUTION, undefined, SolutionCategory.GRAPH)).toBe(
-      '/workbooks?tab=solution&categories=GRAPH',
-    );
-  });
-
-  test('curriculum tab without grade produces URL with tab only', () => {
-    expect(buildWorkbooksUrl(WorkBookTab.CURRICULUM)).toBe('/workbooks?tab=curriculum');
-  });
-
-  test('created_by_user tab produces URL with tab only', () => {
-    expect(buildWorkbooksUrl(WorkBookTab.CREATED_BY_USER)).toBe('/workbooks?tab=created_by_user');
+  describe('with curriculum tab', () => {
+    test('produces URL with tab only when grade is not provided', () => {
+      expect(buildWorkbooksUrl(WorkBookTab.CURRICULUM)).toBe('/workbooks?tab=curriculum');
+    });
+
+    test('produces URL with tab and grade when grade is provided', () => {
+      expect(buildWorkbooksUrl(WorkBookTab.CURRICULUM, TaskGrade.Q9)).toBe(
+        '/workbooks?tab=curriculum&grades=Q9',
+      );
+    });
+  });
+
+  describe('with solution tab', () => {
+    test('produces URL with tab only when category is null', () => {
+      expect(buildWorkbooksUrl(WorkBookTab.SOLUTION, undefined, null)).toBe(
+        '/workbooks?tab=solution',
+      );
+    });
+
+    test('produces URL with tab and category when category is provided', () => {
+      expect(buildWorkbooksUrl(WorkBookTab.SOLUTION, undefined, SolutionCategory.GRAPH)).toBe(
+        '/workbooks?tab=solution&categories=GRAPH',
+      );
+    });
+  });
+
+  describe('with created_by_user tab', () => {
+    test('produces URL with tab only', () => {
+      expect(buildWorkbooksUrl(WorkBookTab.CREATED_BY_USER)).toBe('/workbooks?tab=created_by_user');
+    });
   });
 });
diff --git a/src/features/workbooks/utils/workbook_url_params.ts b/src/features/workbooks/utils/workbook_url_params.ts
index 684ac23e6..a427aecb4 100644
--- a/src/features/workbooks/utils/workbook_url_params.ts
+++ b/src/features/workbooks/utils/workbook_url_params.ts
@@ -1,9 +1,12 @@
 import { TaskGrade } from '$lib/types/task';
 import { WorkBookTab, DEFAULT_WORKBOOK_TAB } from '$features/workbooks/types/workbook';
-import { SolutionCategory } from '$features/workbooks/types/workbook_placement';
+import {
+  SolutionCategory,
+  ALL_SOLUTION_CATEGORIES,
+  type SelectedSolutionCategory,
+} from '$features/workbooks/types/workbook_placement';
 
 const DEFAULT_CURRICULUM_GRADE = TaskGrade.Q10;
-const DEFAULT_SOLUTION_CATEGORY = SolutionCategory.SEARCH_SIMULATION;
 const EXISTING_TABS = new Set<string>(Object.values(WorkBookTab));
 
 /**
@@ -39,19 +42,15 @@ export function parseWorkBookGrade(params: URLSearchParams): TaskGrade {
 }
 
 /**
- * Parses the `?categories=` URL parameter into a SolutionCategory.
- * Excludes PENDING. Falls back to SEARCH_SIMULATION for missing or invalid values.
+ * Parses the `?categories=` URL parameter into a SelectedSolutionCategory.
+ * Returns null (all categories) when the parameter is absent, invalid, or PENDING.
+ * PENDING is excluded because it is admin-only and managed via the order page, not via URL.
  *
  * @param params - URL search params to read from
  */
-export function parseWorkBookCategory(params: URLSearchParams): SolutionCategory {
+export function parseWorkBookCategory(params: URLSearchParams): SelectedSolutionCategory {
   const param = params.get('categories');
-
-  if (isValidNonPending(param, Object.values(SolutionCategory), SolutionCategory.PENDING)) {
-    return param;
-  }
-
-  return DEFAULT_SOLUTION_CATEGORY;
+  return isSelectableCategory(param) ? param : ALL_SOLUTION_CATEGORIES;
 }
 
 /**
@@ -66,7 +65,7 @@ export function parseWorkBookCategory(params: URLSearchParams): SolutionCategory
 export function buildWorkbooksUrl(
   tab: WorkBookTab,
   grade?: TaskGrade,
-  category?: SolutionCategory,
+  category?: SelectedSolutionCategory,
 ): string {
   const params = new URLSearchParams();
   params.set('tab', tab);
@@ -74,6 +73,7 @@ export function buildWorkbooksUrl(
   if (tab === WorkBookTab.CURRICULUM && grade) {
     params.set('grades', grade);
   } else if (tab === WorkBookTab.SOLUTION && category) {
+    // When category is null (ALL), it is falsy and not appended to params
     params.set('categories', category);
   }
 
@@ -91,3 +91,14 @@ function isValidNonPending<T extends string>(
 ): param is T {
   return param !== null && (values as string[]).includes(param) && param !== pending;
 }
+
+/** Returns true when category is a SolutionCategory selectable via URL (excludes PENDING). */
+function isSelectableCategory(
+  category: string | null,
+): category is Exclude<SolutionCategory, 'PENDING'> {
+  return (
+    category !== null &&
+    (Object.values(SolutionCategory) as string[]).includes(category) &&
+    category !== SolutionCategory.PENDING
+  );
+}
diff --git a/src/routes/workbooks/+page.server.ts b/src/routes/workbooks/+page.server.ts
index 0f01d1f39..972402bc8 100644
--- a/src/routes/workbooks/+page.server.ts
+++ b/src/routes/workbooks/+page.server.ts
@@ -10,12 +10,18 @@ import {
   type WorkBookTab as WorkBookTabType,
   WorkBookType,
 } from '$features/workbooks/types/workbook';
-import { type PlacementQuery } from '$features/workbooks/types/workbook_placement';
+import {
+  type PlacementQuery,
+  ALL_SOLUTION_CATEGORIES,
+  type SelectedSolutionCategory,
+  type SolutionCategory,
+} from '$features/workbooks/types/workbook_placement';
 
 import {
   getWorkbooksByPlacement,
   getWorkBooksCreatedByUsers,
   getAvailableSolutionCategories,
+  getSolutionCategoryMapByWorkbookId,
 } from '$features/workbooks/services/workbooks';
 
 import { isAdmin, getLoggedInUser, canDelete } from '$lib/utils/authorship';
@@ -53,11 +59,20 @@ export async function load({ locals, url }) {
   const adminUser = loggedInUser && isAdmin(loggedInUser.role as Roles);
 
   try {
-    const [workbooks, availableCategories, tasksMapByIds, taskResultsByTaskId] = await Promise.all([
+    const [
+      workbooks,
+      availableCategories,
+      solutionCategoryMap,
+      tasksMapByIds,
+      taskResultsByTaskId,
+    ] = await Promise.all([
       fetchWorkbooksByTab(tab, selectedGrade, selectedCategory, !!adminUser),
       tab === WorkBookTab.SOLUTION
         ? getAvailableSolutionCategories(!!adminUser)
         : Promise.resolve([]),
+      tab === WorkBookTab.SOLUTION && selectedCategory === ALL_SOLUTION_CATEGORIES
+        ? getSolutionCategoryMapByWorkbookId(!!adminUser)
+        : Promise.resolve(new Map<number, SolutionCategory>()),
       taskCrud.getTasksByTaskId(),
       loggedInUser
         ? taskResultsCrud.getTaskResultsOnlyResultExists(loggedInUser.id, true)
@@ -67,6 +82,7 @@ export async function load({ locals, url }) {
     return {
       workbooks,
       availableCategories,
+      solutionCategoryMap,
       tasksMapByIds,
       taskResultsByTaskId,
       loggedInUser,
@@ -133,7 +149,7 @@ function fetchWorkbooksByTab(
 function buildPlacementQuery(
   tab: WorkBookTabType,
   grade: ReturnType<typeof parseWorkBookGrade>,
-  category: ReturnType<typeof parseWorkBookCategory>,
+  category: SelectedSolutionCategory,
 ): PlacementQuery {
   if (tab === WorkBookTab.CURRICULUM) {
     return { workBookType: WorkBookType.CURRICULUM, taskGrade: grade };
diff --git a/src/routes/workbooks/+page.svelte b/src/routes/workbooks/+page.svelte
index 9f2fe682f..5f45df0d8 100644
--- a/src/routes/workbooks/+page.svelte
+++ b/src/routes/workbooks/+page.svelte
@@ -13,7 +13,7 @@
     WorkBookType,
     WorkBookTab,
   } from '$features/workbooks/types/workbook';
-  import { type SolutionCategory } from '$features/workbooks/types/workbook_placement';
+  import { type SelectedSolutionCategory } from '$features/workbooks/types/workbook_placement';
 
   import HeadingOne from '$lib/components/HeadingOne.svelte';
   import WorkbookTabItem from '$features/workbooks/components/list/WorkbookTabItem.svelte';
@@ -78,7 +78,7 @@
     goto(resolve(buildWorkbooksUrl(WorkBookTab.CURRICULUM, grade)));
   }
 
-  function handleCategoryChange(category: SolutionCategory) {
+  function handleCategoryChange(category: SelectedSolutionCategory) {
     // @ts-expect-error svelte-check TS2554: same declaration merging issue
     goto(resolve(buildWorkbooksUrl(WorkBookTab.SOLUTION, undefined, category)));
   }
@@ -135,6 +135,7 @@
               loggedInUser={loggedInUser as { id: string; role: Roles }}
               availableCategories={data.availableCategories}
               currentCategory={data.selectedCategory}
+              solutionCategoryMap={data.solutionCategoryMap}
               onCategoryChange={handleCategoryChange}
             />
           </div>