diff --git a/e2e/tests/work-view/sections.spec.ts b/e2e/tests/work-view/sections.spec.ts
new file mode 100644
index 0000000000..abc1993210
--- /dev/null
+++ b/e2e/tests/work-view/sections.spec.ts
@@ -0,0 +1,324 @@
+import { expect, test } from '../../fixtures/test.fixture';
+
+/**
+ * Basic e2e coverage for the Sections feature.
+ *
+ * Sections live inside a project (and tag/today, but project is the
+ * simpler isolated surface). Each test creates its own project so they
+ * stay independent and the testPrefix keeps names unique across workers.
+ */
+test.describe('Sections', () => {
+  /**
+   * Create a fresh project and navigate to it. Avoids
+   * `createAndGoToTestProject()` which hits a strict-mode `.nav-children`
+   * violation when both Projects and Tags trees are expanded.
+   */
+  const setupTestProject = async (
+    workViewPage: import('../../pages/work-view.page').WorkViewPage,
+    projectPage: import('../../pages/project.page').ProjectPage,
+    projectName: string = 'Test Project',
+  ): Promise<void> => {
+    await workViewPage.waitForTaskList();
+    await projectPage.createProject(projectName);
+    await projectPage.navigateToProjectByName(projectName);
+  };
+
+  /**
+   * Open the work-context menu via the page-title's `.project-settings-btn`
+   * (the more_vert icon next to the project title in the main header).
+   * This is the same menu the side-nav `additional-btn` opens, but the
+   * header trigger is always visible without hover and isn't sensitive to
+   * the tree's expand/collapse state.
+   */
+  const openProjectContextMenu = async (
+    page: import('@playwright/test').Page,
+  ): Promise<void> => {
+    const trigger = page.locator('.project-settings-btn');
+    await trigger.waitFor({ state: 'visible', timeout: 10000 });
+    await trigger.click();
+    await page
+      .locator('work-context-menu')
+      .first()
+      .waitFor({ state: 'visible', timeout: 5000 });
+  };
+
+  /** Click the "Add Section" item in the open work-context menu. */
+  const clickAddSection = async (
+    page: import('@playwright/test').Page,
+  ): Promise<void> => {
+    await page.getByRole('menuitem', { name: 'Add Section' }).click();
+  };
+
+  /** Fill the dialog-prompt input and submit. */
+  const submitPromptDialog = async (
+    page: import('@playwright/test').Page,
+    title: string,
+  ): Promise<void> => {
+    const dialog = page.locator('mat-dialog-container');
+    await dialog.waitFor({ state: 'visible', timeout: 5000 });
+    const input = dialog.locator('input[type="text"]').first();
+    await input.fill(title);
+    await dialog.getByRole('button', { name: 'Save' }).click();
+    await dialog.waitFor({ state: 'hidden', timeout: 5000 });
+  };
+
+  /** Locator for a rendered section block in the work view by title. */
+  const sectionByTitle = (
+    page: import('@playwright/test').Page,
+    title: string,
+  ): ReturnType<import('@playwright/test').Page['locator']> =>
+    page.locator('.section-container').filter({ hasText: title });
+
+  /**
+   * CDK drag-drop is event-driven via Angular CDK's own pointer-event
+   * handling. Playwright's `dragTo` uses HTML5 drag-and-drop events,
+   * which CDK ignores. Drive the gesture manually with multi-step mouse
+   * moves so the CDK threshold + drag start fires.
+   */
+  const cdkDragTo = async (
+    page: import('@playwright/test').Page,
+    source: import('@playwright/test').Locator,
+    target: import('@playwright/test').Locator,
+  ): Promise<void> => {
+    const sBox = await source.boundingBox();
+    const tBox = await target.boundingBox();
+    if (!sBox || !tBox) throw new Error('drag source/target has no bounding box');
+    /* eslint-disable no-mixed-operators */
+    const sx = sBox.x + sBox.width / 2;
+    const sy = sBox.y + sBox.height / 2;
+    const tx = tBox.x + tBox.width / 2;
+    const ty = tBox.y + tBox.height / 2;
+    /* eslint-enable no-mixed-operators */
+
+    await page.mouse.move(sx, sy);
+    await page.mouse.down();
+    // Initial nudge past CDK's drag threshold (5px by default).
+    await page.mouse.move(sx + 10, sy + 10, { steps: 5 });
+    // Smooth move to target so each `mousemove` re-evaluates drop target.
+    await page.mouse.move(tx, ty, { steps: 20 });
+    await page.mouse.up();
+  };
+
+  test('creates a section via the project context menu', async ({
+    page,
+    workViewPage,
+    projectPage,
+  }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    await openProjectContextMenu(page);
+    await clickAddSection(page);
+    await submitPromptDialog(page, 'My Section');
+
+    await expect(sectionByTitle(page, 'My Section')).toBeVisible();
+  });
+
+  test('creates a section via right-click on the work-view background', async ({
+    page,
+    workViewPage,
+    projectPage,
+  }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    // The app-level bg context menu (shared with "Change Settings") only
+    // opens when the click target itself matches the allowed selectors,
+    // not on descendants. dispatchEvent fires the contextmenu directly
+    // on the wrapper so target.matches('.task-list-wrapper') holds.
+    const wrapper = page.locator('.task-list-wrapper').first();
+    await wrapper.waitFor({ state: 'visible', timeout: 5000 });
+    await wrapper.dispatchEvent('contextmenu');
+
+    await page.getByRole('menuitem', { name: 'Add Section' }).click();
+    await submitPromptDialog(page, 'Right-Click Section');
+
+    await expect(sectionByTitle(page, 'Right-Click Section')).toBeVisible();
+  });
+
+  test('rejects whitespace-only section titles', async ({
+    page,
+    workViewPage,
+    projectPage,
+  }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    await openProjectContextMenu(page);
+    await clickAddSection(page);
+
+    const dialog = page.locator('mat-dialog-container');
+    await dialog.waitFor({ state: 'visible', timeout: 5000 });
+    const input = dialog.locator('input[type="text"]').first();
+    await input.fill('   ');
+    // The form's `required` validator considers whitespace truthy as a
+    // string, so Save dispatches — but the component-side trim guard
+    // (work-context-menu.component.ts) drops the dispatch. Verify no
+    // section appears.
+    await dialog.getByRole('button', { name: 'Save' }).click();
+    // Dialog may stay open (required validation) or close without effect.
+    // Either way the section list must remain empty — `toHaveCount`
+    // already polls so no separate wait is needed.
+    await expect(page.locator('.section-container')).toHaveCount(0, { timeout: 1500 });
+  });
+
+  test('edits an existing section title', async ({ page, workViewPage, projectPage }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    await openProjectContextMenu(page);
+    await clickAddSection(page);
+    await submitPromptDialog(page, 'Original');
+
+    const section = sectionByTitle(page, 'Original');
+    await expect(section).toBeVisible();
+
+    // Open the section's per-section menu and click Edit.
+    await section.locator('button[mat-icon-button]').click();
+    await page.getByRole('menuitem', { name: 'Edit' }).click();
+
+    const dialog = page.locator('mat-dialog-container');
+    await dialog.waitFor({ state: 'visible', timeout: 5000 });
+    const input = dialog.locator('input[type="text"]').first();
+    await input.fill('Renamed');
+    await dialog.getByRole('button', { name: 'Save' }).click();
+    await dialog.waitFor({ state: 'hidden', timeout: 5000 });
+
+    await expect(sectionByTitle(page, 'Renamed')).toBeVisible();
+    await expect(sectionByTitle(page, 'Original')).toHaveCount(0);
+  });
+
+  test('deletes a section after confirmation', async ({
+    page,
+    workViewPage,
+    projectPage,
+  }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    await openProjectContextMenu(page);
+    await clickAddSection(page);
+    await submitPromptDialog(page, 'Doomed');
+
+    const section = sectionByTitle(page, 'Doomed');
+    await expect(section).toBeVisible();
+
+    await section.locator('button[mat-icon-button]').click();
+    await page.getByRole('menuitem', { name: 'Delete' }).click();
+
+    const confirm = page.locator('dialog-confirm');
+    await confirm.waitFor({ state: 'visible', timeout: 5000 });
+    // The confirmation has an OK / Confirm button — match either.
+    await confirm
+      .getByRole('button', { name: /^(OK|Confirm)$/i })
+      .first()
+      .click();
+    await confirm.waitFor({ state: 'hidden', timeout: 5000 });
+
+    await expect(sectionByTitle(page, 'Doomed')).toHaveCount(0);
+  });
+
+  test('drops a task into a section via drag and drop', async ({
+    page,
+    workViewPage,
+    projectPage,
+  }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    // Add task BEFORE creating the section so it lives in the no-section
+    // bucket initially.
+    await workViewPage.addTask('Movable');
+    await page.waitForSelector('task', { state: 'visible' });
+
+    await openProjectContextMenu(page);
+    await clickAddSection(page);
+    await submitPromptDialog(page, 'Target');
+
+    const section = sectionByTitle(page, 'Target');
+    await expect(section).toBeVisible();
+    // The section's inner task-list is the drop target.
+    const sectionTaskList = section.locator('task-list').first();
+    const noSectionTaskList = page.locator('.no-section task-list').first();
+
+    // Drag handle is `done-toggle` (per task-dragdrop.spec.ts).
+    const task = page.locator('task').filter({ hasText: 'Movable' }).first();
+    const dragHandle = task.locator('done-toggle').first();
+
+    await cdkDragTo(page, dragHandle, sectionTaskList);
+
+    // Task should now render inside the section, not in the no-section list.
+    await expect(section.locator('task').filter({ hasText: 'Movable' })).toBeVisible({
+      timeout: 5000,
+    });
+    await expect(
+      noSectionTaskList.locator('task').filter({ hasText: 'Movable' }),
+    ).toHaveCount(0);
+  });
+
+  // FIXME: round-trip drag (section → no-section) is flaky in headless CDK.
+  // The forward "into section" drag passes; the reverse fails to register the
+  // drop on the empty `.no-section` task-list whose bounding box collapses
+  // to its hint-message. Driving CDK pointer events deterministically here
+  // is non-trivial — track as a follow-up and exercise reverse moves via
+  // unit tests in section.reducer.spec.ts (`removeTaskFromSection`).
+  test.fixme('drags a task back out of a section into the main list', async ({
+    page,
+    workViewPage,
+    projectPage,
+  }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    await workViewPage.addTask('Roundtrip');
+    await page.waitForSelector('task', { state: 'visible' });
+
+    await openProjectContextMenu(page);
+    await clickAddSection(page);
+    await submitPromptDialog(page, 'Holding');
+
+    const section = sectionByTitle(page, 'Holding');
+    const sectionTaskList = section.locator('task-list').first();
+    // Target the wrapper `.no-section` div, not the inner task-list — when
+    // the no-section bucket is empty the task-list collapses to its hint
+    // text and may have a too-small bounding box for a stable drop.
+    const noSection = page.locator('.no-section').first();
+
+    const task = page.locator('task').filter({ hasText: 'Roundtrip' }).first();
+    let dragHandle = task.locator('done-toggle').first();
+
+    // Move into section.
+    await cdkDragTo(page, dragHandle, sectionTaskList);
+    const taskInSection = section
+      .locator('task')
+      .filter({ hasText: 'Roundtrip' })
+      .first();
+    await expect(taskInSection).toBeVisible();
+
+    // Move back out — re-acquire handle from the new DOM location.
+    dragHandle = taskInSection.locator('done-toggle').first();
+    await cdkDragTo(page, dragHandle, noSection);
+
+    await expect(noSection.locator('task').filter({ hasText: 'Roundtrip' })).toBeVisible({
+      timeout: 5000,
+    });
+    await expect(section.locator('task').filter({ hasText: 'Roundtrip' })).toHaveCount(0);
+  });
+
+  test('sections persist across a page reload', async ({
+    page,
+    workViewPage,
+    projectPage,
+  }) => {
+    await setupTestProject(workViewPage, projectPage);
+
+    await openProjectContextMenu(page);
+    await clickAddSection(page);
+    await submitPromptDialog(page, 'Persistent');
+
+    await expect(sectionByTitle(page, 'Persistent')).toBeVisible();
+
+    // Reload — the project view re-hydrates from IndexedDB.
+    await page.reload();
+    await workViewPage.waitForTaskList();
+
+    // The reload may land on Today; navigate back to the project so the
+    // section list is what's rendered.
+    await projectPage.navigateToProjectByName('Test Project');
+
+    await expect(sectionByTitle(page, 'Persistent')).toBeVisible({ timeout: 10000 });
+  });
+});
diff --git a/packages/shared-schema/src/entity-types.ts b/packages/shared-schema/src/entity-types.ts
index 2b959d95ac..a1ba59c04e 100644
--- a/packages/shared-schema/src/entity-types.ts
+++ b/packages/shared-schema/src/entity-types.ts
@@ -27,6 +27,7 @@ export const ENTITY_TYPES = [
   'MENU_TREE',
   'METRIC',
   'BOARD',
+  'SECTION',
   'REMINDER',
   'PLUGIN_USER_DATA',
   'PLUGIN_METADATA',
diff --git a/src/app/app.component.html b/src/app/app.component.html
index 9324db727b..6fb0b9d672 100644
--- a/src/app/app.component.html
+++ b/src/app/app.component.html
@@ -111,5 +111,19 @@
         ) | translate
       }}</span>
     </button>
+    @if (
+      workContextService.activeWorkContextType === 'PROJECT' ||
+      workContextService.activeWorkContextId === TODAY_TAG_ID
+    ) {
+      <button
+        mat-menu-item
+        (click)="addSection()"
+        class="background-menu-item"
+        style="width: 100%; overflow: hidden"
+      >
+        <mat-icon>list</mat-icon>
+        <span>{{ T.MH.ADD_SECTION | translate }}</span>
+      </button>
+    }
   </div>
 </ng-template>
diff --git a/src/app/app.component.ts b/src/app/app.component.ts
index d6b083315d..38731b35be 100644
--- a/src/app/app.component.ts
+++ b/src/app/app.component.ts
@@ -60,6 +60,9 @@ import { ProjectService } from './features/project/project.service';
 import { TagService } from './features/tag/tag.service';
 import { ContextMenuComponent } from './ui/context-menu/context-menu.component';
 import { WorkContextType } from './features/work-context/work-context.model';
+import { SectionService } from './features/section/section.service';
+import { DialogPromptComponent } from './ui/dialog-prompt/dialog-prompt.component';
+import { TODAY_TAG } from './features/tag/tag.const';
 import type { WorkContextSettingsDialogData } from './features/work-context/dialog-work-context-settings/dialog-work-context-settings.component';
 import { isInputElement } from './util/dom-element';
 import { MobileBottomNavComponent } from './core-ui/mobile-bottom-nav/mobile-bottom-nav.component';
@@ -143,7 +146,9 @@ export class AppComponent implements OnDestroy, AfterViewInit {
   readonly layoutService = inject(LayoutService);
   readonly globalThemeService = inject(GlobalThemeService);
   readonly _store = inject(Store);
+  private _sectionService = inject(SectionService);
   readonly T = T;
+  readonly TODAY_TAG_ID = TODAY_TAG.id;
   readonly isShowMobileButtonNav = this.layoutService.isShowMobileBottomNav;
 
   @ViewChild('routeWrapper', { read: ElementRef }) routeWrapper?: ElementRef<HTMLElement>;
@@ -277,16 +282,16 @@ export class AppComponent implements OnDestroy, AfterViewInit {
     let taskTitle: string | null = null;
     let isSubTask = false;
 
-    // Find task element by traversing up the DOM tree
-    let element: HTMLElement | null = target;
-    while (element && !element.id.startsWith('t-')) {
-      element = element.parentElement;
+    // Find the nearest task element via the data-task-id attribute (set
+    // on the <task> host). Avoids brittle id-prefix scans that could match
+    // unrelated elements whose id happens to start with "t-".
+    const taskEl = target.closest<HTMLElement>('[data-task-id]');
+
+    if (taskEl) {
+      taskId = taskEl.getAttribute('data-task-id');
     }
 
-    if (element && element.id.startsWith('t-')) {
-      // Extract task ID from DOM id (format: "t-{taskId}")
-      taskId = element.id.substring(2);
-
+    if (taskId) {
       // Get task data to determine if it's a sub-task
       this._taskService.getByIdOnce$(taskId).subscribe((task) => {
         if (task) {
@@ -389,6 +394,20 @@ export class AppComponent implements OnDestroy, AfterViewInit {
     });
   }
 
+  async addSection(): Promise<void> {
+    const ctxId = this.workContextService.activeWorkContextId;
+    const ctxType = this.workContextService.activeWorkContextType;
+    if (!ctxId || !ctxType) return;
+    const title = await firstValueFrom(
+      this._matDialog
+        .open(DialogPromptComponent, { data: { placeholder: T.WW.ADD_SECTION_TITLE } })
+        .afterClosed(),
+    );
+    if (typeof title === 'string' && title.trim()) {
+      this._sectionService.addSection(title, ctxId, ctxType);
+    }
+  }
+
   isAppEntrance = signal(!this.isShowOnboardingPresets());
 
   onPresetSelected(): void {
diff --git a/src/app/core-ui/drop-list/drop-list.service.ts b/src/app/core-ui/drop-list/drop-list.service.ts
index f4f5525c7d..a1cf278712 100644
--- a/src/app/core-ui/drop-list/drop-list.service.ts
+++ b/src/app/core-ui/drop-list/drop-list.service.ts
@@ -7,23 +7,44 @@ import { map, startWith, switchMap } from 'rxjs/operators';
   providedIn: 'root',
 })
 export class DropListService {
-  dropLists = new BehaviorSubject<CdkDropList[]>([]);
+  // Coalesce burst register/unregister calls (e.g. dozens of sections
+  // mounting in one CD pass) into a single downstream emission via a
+  // microtask flush. `cdkDropListConnectedTo` rebuilds its sibling
+  // graph per emission, so without this every list mount would be
+  // O(L²) total.
+  readonly dropLists = new BehaviorSubject<CdkDropList[]>([]);
+
   blockAniTrigger$ = new Subject<void>();
   isBlockAniAfterDrop$ = this.blockAniTrigger$.pipe(
     switchMap(() => merge(of(true), timer(1200).pipe(map(() => false)))),
     startWith(false),
   );
 
+  private _list: CdkDropList[] = [];
+  private _flushScheduled = false;
+
   registerDropList(dropList: CdkDropList, isSubTaskList = false): void {
     if (isSubTaskList) {
-      this.dropLists.next([dropList, ...this.dropLists.getValue()]);
+      this._list.unshift(dropList);
     } else {
-      this.dropLists.next([...this.dropLists.getValue(), dropList]);
+      this._list.push(dropList);
     }
-    // Log.log(this.dropLists.getValue());
+    this._scheduleFlush();
   }
 
   unregisterDropList(dropList: CdkDropList): void {
-    this.dropLists.next(this.dropLists.getValue().filter((dl) => dl !== dropList));
+    const idx = this._list.indexOf(dropList);
+    if (idx === -1) return;
+    this._list.splice(idx, 1);
+    this._scheduleFlush();
+  }
+
+  private _scheduleFlush(): void {
+    if (this._flushScheduled) return;
+    this._flushScheduled = true;
+    queueMicrotask(() => {
+      this._flushScheduled = false;
+      this.dropLists.next(this._list.slice());
+    });
   }
 }
diff --git a/src/app/core-ui/work-context-menu/work-context-menu.component.html b/src/app/core-ui/work-context-menu/work-context-menu.component.html
index 19d61fd103..26a6c9a396 100644
--- a/src/app/core-ui/work-context-menu/work-context-menu.component.html
+++ b/src/app/core-ui/work-context-menu/work-context-menu.component.html
@@ -49,6 +49,16 @@
   </span>
 </button>
 
+@if (isForProject || contextId === TODAY_TAG_ID) {
+  <button
+    (click)="addSection()"
+    mat-menu-item
+  >
+    <mat-icon>list</mat-icon>
+    <span class="text">{{ T.MH.ADD_SECTION | translate }}</span>
+  </button>
+}
+
 <button
   (click)="openSettings()"
   mat-menu-item
diff --git a/src/app/core-ui/work-context-menu/work-context-menu.component.ts b/src/app/core-ui/work-context-menu/work-context-menu.component.ts
index d6bab155ad..7161f2e52e 100644
--- a/src/app/core-ui/work-context-menu/work-context-menu.component.ts
+++ b/src/app/core-ui/work-context-menu/work-context-menu.component.ts
@@ -17,6 +17,8 @@ import { WorkContextService } from '../../features/work-context/work-context.ser
 import { Router, RouterLink, RouterModule } from '@angular/router';
 
 import { ProjectService } from '../../features/project/project.service';
+import { SectionService } from '../../features/section/section.service';
+import { DialogPromptComponent } from '../../ui/dialog-prompt/dialog-prompt.component';
 import { MatMenuItem } from '@angular/material/menu';
 import { TranslatePipe } from '@ngx-translate/core';
 import { MatIcon } from '@angular/material/icon';
@@ -41,6 +43,7 @@ export class WorkContextMenuComponent implements OnInit {
   private _matDialog = inject(MatDialog);
   private _tagService = inject(TagService);
   private _projectService = inject(ProjectService);
+  private _sectionService = inject(SectionService);
   private _workContextService = inject(WorkContextService);
   private _router = inject(Router);
   private _snackService = inject(SnackService);
@@ -134,6 +137,35 @@ export class WorkContextMenuComponent implements OnInit {
     }
   }
 
+  addSection(): void {
+    this._matDialog
+      .open(DialogPromptComponent, {
+        // Omit `message` to match the Add Tag pattern — the dialog
+        // collapses its outer padding when there's no message text
+        // (`dialog-prompt.scss: mat-dialog-content.isNoMsg`).
+        // Use a descriptive placeholder ("Add Section") rather than a
+        // generic "Title" so screen readers and visual users get the
+        // dialog's purpose without a separate title element.
+        data: {
+          placeholder: T.WW.ADD_SECTION_TITLE,
+        },
+      })
+      // NOTE: do NOT pipe takeUntilDestroyed here. This component lives inside
+      // a <mat-menu>; the menu (and component) is destroyed the moment the
+      // dialog opens, which would unsubscribe before afterClosed() emits.
+      // MatDialog cleans up its own subscription when the dialog closes.
+      .afterClosed()
+      .subscribe((title: string) => {
+        if (title?.trim()) {
+          this._sectionService.addSection(
+            title,
+            this.contextId,
+            this.isForProject ? WorkContextType.PROJECT : WorkContextType.TAG,
+          );
+        }
+      });
+  }
+
   protected readonly INBOX_PROJECT = INBOX_PROJECT;
 
   async shareTasksAsMarkdown(): Promise<void> {
diff --git a/src/app/core/persistence/operation-log/compact/action-type-codes.ts b/src/app/core/persistence/operation-log/compact/action-type-codes.ts
index 6ecdcb7e49..05b87664c3 100644
--- a/src/app/core/persistence/operation-log/compact/action-type-codes.ts
+++ b/src/app/core/persistence/operation-log/compact/action-type-codes.ts
@@ -153,6 +153,14 @@ export const ACTION_TYPE_TO_CODE: Record<ActionType, string> = {
   [ActionType.REPEAT_CFG_DELETE_INSTANCE]: 'RDI',
   [ActionType.REPEAT_CFG_UPSERT]: 'RX',
 
+  // Section
+  [ActionType.SECTION_ADD]: 'S1',
+  [ActionType.SECTION_DELETE]: 'S2',
+  [ActionType.SECTION_UPDATE]: 'S3',
+  [ActionType.SECTION_UPDATE_ORDER]: 'S4',
+  [ActionType.SECTION_ADD_TASK]: 'S5',
+  [ActionType.SECTION_REMOVE_TASK]: 'S6',
+
   // SimpleCounter actions (S)
   [ActionType.COUNTER_ADD]: 'SA',
   [ActionType.COUNTER_UPDATE]: 'SU',
diff --git a/src/app/features/section/section.model.ts b/src/app/features/section/section.model.ts
new file mode 100644
index 0000000000..3a4dc78431
--- /dev/null
+++ b/src/app/features/section/section.model.ts
@@ -0,0 +1,14 @@
+import { EntityState } from '@ngrx/entity';
+import { WorkContextType } from '../work-context/work-context.model';
+
+export interface Section {
+  id: string;
+  contextId: string;
+  contextType: WorkContextType;
+  title: string;
+  taskIds: string[];
+}
+
+export interface SectionState extends EntityState<Section> {
+  ids: string[];
+}
diff --git a/src/app/features/section/section.service.ts b/src/app/features/section/section.service.ts
new file mode 100644
index 0000000000..297b2fa0db
--- /dev/null
+++ b/src/app/features/section/section.service.ts
@@ -0,0 +1,102 @@
+import { Injectable, inject } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { nanoid } from 'nanoid';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Section } from './section.model';
+import { isValidSectionContext, sanitizeSectionTitle } from './section.util';
+import { WorkContextType } from '../work-context/work-context.model';
+import {
+  addSection,
+  addTaskToSection,
+  deleteSection,
+  removeTaskFromSection,
+  updateSection,
+  updateSectionOrder,
+} from './store/section.actions';
+import { selectSectionsByContextIdMap } from './store/section.selectors';
+
+const EMPTY_SECTIONS: readonly Section[] = Object.freeze([]);
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SectionService {
+  private _store = inject(Store);
+
+  getSectionsByContextId$(contextId: string): Observable<readonly Section[]> {
+    return this._store
+      .select(selectSectionsByContextIdMap)
+      .pipe(map((m) => m.get(contextId) ?? EMPTY_SECTIONS));
+  }
+
+  /**
+   * Sections are only valid for projects and the singleton TODAY tag;
+   * other tags are silently rejected. Returns the new id synchronously
+   * so callers can wire tasks into the just-created section without
+   * awaiting.
+   */
+  addSection(
+    title: string,
+    contextId: string,
+    contextType: WorkContextType,
+  ): string | null {
+    if (!isValidSectionContext(contextId, contextType)) return null;
+    const id = nanoid();
+    this._store.dispatch(
+      addSection({
+        section: {
+          id,
+          contextId,
+          contextType,
+          title: sanitizeSectionTitle(title),
+          taskIds: [],
+        },
+      }),
+    );
+    return id;
+  }
+
+  deleteSection(id: string): void {
+    this._store.dispatch(deleteSection({ id }));
+  }
+
+  updateSection(id: string, changes: Partial<Section>): void {
+    this._store.dispatch(updateSection({ section: { id, changes } }));
+  }
+
+  updateSectionOrder(contextId: string, ids: string[]): void {
+    this._store.dispatch(updateSectionOrder({ contextId, ids }));
+  }
+
+  /**
+   * Atomic: places `taskId` into `targetSectionId` at the position
+   * implied by `afterTaskId`. `sourceSectionId` MUST reflect the task's
+   * current section (or `null` if it isn't in one) so replay strips
+   * from the explicit source rather than searching state.
+   */
+  addTaskToSection(
+    targetSectionId: string,
+    taskId: string,
+    afterTaskId: string | null,
+    sourceSectionId: string | null,
+  ): void {
+    this._store.dispatch(
+      addTaskToSection({
+        sectionId: targetSectionId,
+        taskId,
+        afterTaskId,
+        sourceSectionId,
+      }),
+    );
+  }
+
+  /**
+   * Removes `taskId` from `sourceSectionId`. Persisted as a single
+   * Update keyed on the source — concurrent ungroups from different
+   * sections do NOT collide.
+   */
+  removeTaskFromSection(sourceSectionId: string, taskId: string): void {
+    this._store.dispatch(removeTaskFromSection({ sectionId: sourceSectionId, taskId }));
+  }
+}
diff --git a/src/app/features/section/section.util.ts b/src/app/features/section/section.util.ts
new file mode 100644
index 0000000000..256909042a
--- /dev/null
+++ b/src/app/features/section/section.util.ts
@@ -0,0 +1,26 @@
+import { WorkContextType } from '../work-context/work-context.model';
+import { TODAY_TAG } from '../tag/tag.const';
+
+export const MAX_SECTION_TITLE_LENGTH = 200;
+
+/**
+ * Authoritative title normalizer. Applied in the reducer so it survives
+ * remote sync replay — a peer cannot bypass the cap by talking directly
+ * to the op-log. Non-string input (a malformed peer payload with
+ * `null`, `undefined`, a Symbol, or an object with a malicious
+ * `toString`) returns `''` rather than throwing.
+ */
+export const sanitizeSectionTitle = (title: unknown): string =>
+  typeof title === 'string' ? title.trim().slice(0, MAX_SECTION_TITLE_LENGTH) : '';
+
+/**
+ * Sections are scoped to projects and the singleton TODAY tag only.
+ * Custom tags don't host sections — the cleanup overhead (cascading on
+ * tag delete + tagIds update) outweighed the use case.
+ */
+export const isValidSectionContext = (
+  contextId: string,
+  contextType: WorkContextType,
+): boolean =>
+  contextType === WorkContextType.PROJECT ||
+  (contextType === WorkContextType.TAG && contextId === TODAY_TAG.id);
diff --git a/src/app/features/section/store/section.actions.ts b/src/app/features/section/store/section.actions.ts
new file mode 100644
index 0000000000..ab5e5df041
--- /dev/null
+++ b/src/app/features/section/store/section.actions.ts
@@ -0,0 +1,114 @@
+import { createAction } from '@ngrx/store';
+import { Update } from '@ngrx/entity';
+import { Section } from '../section.model';
+import { PersistentActionMeta } from '../../../op-log/core/persistent-action.interface';
+import { OpType } from '../../../op-log/core/operation.types';
+
+export const addSection = createAction(
+  '[Section] Add Section',
+  (payload: { section: Section }) => ({
+    ...payload,
+    meta: {
+      isPersistent: true,
+      entityType: 'SECTION',
+      entityId: payload.section.id,
+      opType: OpType.Create,
+    } satisfies PersistentActionMeta,
+  }),
+);
+
+export const deleteSection = createAction(
+  '[Section] Delete Section',
+  (payload: { id: string }) => ({
+    ...payload,
+    meta: {
+      isPersistent: true,
+      entityType: 'SECTION',
+      entityId: payload.id,
+      opType: OpType.Delete,
+    } satisfies PersistentActionMeta,
+  }),
+);
+
+export const updateSection = createAction(
+  '[Section] Update Section',
+  (payload: { section: Update<Section> }) => ({
+    ...payload,
+    meta: {
+      isPersistent: true,
+      entityType: 'SECTION',
+      entityId: payload.section.id as string,
+      opType: OpType.Update,
+    } satisfies PersistentActionMeta,
+  }),
+);
+
+export const updateSectionOrder = createAction(
+  '[Section] Update Section Order',
+  (payload: { contextId: string; ids: string[] }) => ({
+    ...payload,
+    meta: {
+      isPersistent: true,
+      entityType: 'SECTION',
+      entityIds: payload.ids,
+      opType: OpType.Move,
+      isBulk: true,
+    } satisfies PersistentActionMeta,
+  }),
+);
+
+/**
+ * Atomically place `taskId` into `sectionId` at `afterTaskId`.
+ * `sourceSectionId` is part of the payload so replay is deterministic:
+ * different from `sectionId` → strip from source (meta covers both via
+ * `entityIds`); equal or `null` → single-entity update on `sectionId`.
+ *
+ * FOLLOW-UP: a `task.sectionId` membership model would atomize cross-
+ * section moves and obviate most of section-shared.reducer.ts. Needs a
+ * migration path for existing data — out of scope.
+ */
+export const addTaskToSection = createAction(
+  '[Section] Add Task to Section',
+  (payload: {
+    sectionId: string;
+    taskId: string;
+    afterTaskId: string | null;
+    sourceSectionId: string | null;
+  }) => ({
+    ...payload,
+    meta: {
+      isPersistent: true,
+      entityType: 'SECTION',
+      ...(payload.sourceSectionId && payload.sourceSectionId !== payload.sectionId
+        ? { entityIds: [payload.sourceSectionId, payload.sectionId] }
+        : { entityId: payload.sectionId }),
+      opType: OpType.Move,
+    } satisfies PersistentActionMeta,
+  }),
+);
+
+/**
+ * Remove `taskId` from `sectionId`. Used when a task is dragged out of a
+ * section into the "no section" area. Persisted as an Update on the
+ * source section so concurrent ungroups from different sections never
+ * collide on a sentinel id (the prior 'NONE' approach).
+ *
+ * FOLLOW-UP (simplicity): this action duplicates a lot of
+ * `addTaskToSection`. Folding it into `addTaskToSection` with a nullable
+ * `sectionId` would drop one action, one op-log code (S6), and one
+ * reducer branch. Held back because the two actions use different
+ * opTypes (Move vs Update) and the meta-builder asymmetry would need
+ * sync-replay validation. Out of scope for this PR.
+ */
+export const removeTaskFromSection = createAction(
+  '[Section] Remove Task from Section',
+  (payload: { sectionId: string; taskId: string }) => ({
+    ...payload,
+    meta: {
+      isPersistent: true,
+      entityType: 'SECTION',
+      entityId: payload.sectionId,
+      opType: OpType.Update,
+    } satisfies PersistentActionMeta,
+  }),
+);
diff --git a/src/app/features/section/store/section.reducer.spec.ts b/src/app/features/section/store/section.reducer.spec.ts
new file mode 100644
index 0000000000..082e6534e2
--- /dev/null
+++ b/src/app/features/section/store/section.reducer.spec.ts
@@ -0,0 +1,373 @@
+import { initialSectionState, sectionReducer } from './section.reducer';
+import {
+  addSection,
+  addTaskToSection,
+  deleteSection,
+  removeTaskFromSection,
+  updateSection,
+  updateSectionOrder,
+} from './section.actions';
+import { Section, SectionState } from '../section.model';
+import { MAX_SECTION_TITLE_LENGTH } from '../section.util';
+import { WorkContextType } from '../../work-context/work-context.model';
+
+const makeSection = (overrides: Partial<Section> = {}): Section => ({
+  id: 's1',
+  contextId: 'project1',
+  contextType: WorkContextType.PROJECT,
+  title: 'Section 1',
+  taskIds: [],
+  ...overrides,
+});
+
+const stateWithSections = (sections: Section[]): SectionState => {
+  const ids = sections.map((s) => s.id);
+  const entities: Record<string, Section> = {};
+  for (const s of sections) entities[s.id] = s;
+  return { ids, entities };
+};
+
+describe('sectionReducer', () => {
+  describe('addSection', () => {
+    it('adds the section with empty taskIds when none provided', () => {
+      const action = addSection({
+        section: {
+          id: 'new',
+          contextId: 'p1',
+          contextType: WorkContextType.PROJECT,
+          title: 'New',
+        } as Section,
+      });
+      const next = sectionReducer(initialSectionState, action);
+      expect(next.entities['new']?.taskIds).toEqual([]);
+      expect(next.ids).toContain('new');
+    });
+
+    it('preserves provided taskIds', () => {
+      const action = addSection({
+        section: makeSection({ id: 'new', taskIds: ['t1', 't2'] }),
+      });
+      const next = sectionReducer(initialSectionState, action);
+      expect(next.entities['new']?.taskIds).toEqual(['t1', 't2']);
+    });
+  });
+
+  describe('deleteSection', () => {
+    it('removes only the entity (no task cascade)', () => {
+      const start = stateWithSections([
+        makeSection({ id: 's1', taskIds: ['t1', 't2'] }),
+        makeSection({ id: 's2' }),
+      ]);
+      const next = sectionReducer(start, deleteSection({ id: 's1' }));
+      expect(next.entities['s1']).toBeUndefined();
+      expect(next.entities['s2']).toBeDefined();
+      expect(next.ids).toEqual(['s2']);
+    });
+  });
+
+  describe('updateSection', () => {
+    it('applies partial changes', () => {
+      const start = stateWithSections([
+        makeSection({ id: 's1', title: 'old', taskIds: ['t1'] }),
+      ]);
+      const next = sectionReducer(
+        start,
+        updateSection({ section: { id: 's1', changes: { title: 'new' } } }),
+      );
+      expect(next.entities['s1']?.title).toBe('new');
+      expect(next.entities['s1']?.taskIds).toEqual(['t1']);
+    });
+
+    it('trims and caps incoming title length even when the action came from sync', () => {
+      // Reducer-side enforcement defends against remote ops that bypass
+      // the service-level sanitizer (e.g. a malicious peer's op-log entry).
+      const start = stateWithSections([makeSection({ id: 's1', title: 'short' })]);
+      const longTitle = '  ' + 'x'.repeat(500) + '  ';
+      const next = sectionReducer(
+        start,
+        updateSection({ section: { id: 's1', changes: { title: longTitle } } }),
+      );
+      const updated = next.entities['s1']?.title;
+      expect(updated?.length).toBe(MAX_SECTION_TITLE_LENGTH);
+      expect(updated?.startsWith(' ')).toBe(false);
+    });
+
+    it('passes the empty string through (legitimate title clear)', () => {
+      const start = stateWithSections([makeSection({ id: 's1', title: 'old' })]);
+      const next = sectionReducer(
+        start,
+        updateSection({ section: { id: 's1', changes: { title: '' } } }),
+      );
+      expect(next.entities['s1']?.title).toBe('');
+    });
+
+    it('coerces null/undefined title to "" rather than crashing or storing null', () => {
+      // A malformed remote op might ship `title: null` (or `undefined`).
+      // The Section.title contract is `string` — must never become null.
+      const start = stateWithSections([makeSection({ id: 's1', title: 'old' })]);
+      const nextNull = sectionReducer(
+        start,
+        updateSection({
+          section: { id: 's1', changes: { title: null as unknown as string } },
+        }),
+      );
+      expect(nextNull.entities['s1']?.title).toBe('');
+    });
+  });
+
+  describe('addSection (reducer-side title cap)', () => {
+    it('trims whitespace and caps incoming title at 200 chars', () => {
+      const longTitle = '  ' + 'y'.repeat(500) + '  ';
+      const next = sectionReducer(
+        initialSectionState,
+        addSection({
+          section: makeSection({ id: 'new', title: longTitle, taskIds: [] }),
+        }),
+      );
+      expect(next.entities['new']?.title?.length).toBe(MAX_SECTION_TITLE_LENGTH);
+      expect(next.entities['new']?.title?.startsWith(' ')).toBe(false);
+    });
+
+    it('does not throw when a malformed remote op ships an undefined title', () => {
+      // Defends against `addSection({ section: { ...validShape, title: undefined } })`
+      // — the threat model the reducer-side cap was added for. The
+      // sanitizer must coerce, not throw.
+      expect(() =>
+        sectionReducer(
+          initialSectionState,
+          addSection({
+            section: makeSection({
+              id: 'new',
+              title: undefined as unknown as string,
+              taskIds: [],
+            }),
+          }),
+        ),
+      ).not.toThrow();
+    });
+  });
+
+  describe('updateSectionOrder', () => {
+    it('reorders sections within a context, leaving other-context slots intact', () => {
+      const start = stateWithSections([
+        makeSection({ id: 'a', contextId: 'p1' }),
+        makeSection({ id: 'b', contextId: 'p1' }),
+        makeSection({ id: 'c', contextId: 'p2' }),
+      ]);
+      const next = sectionReducer(
+        start,
+        updateSectionOrder({ contextId: 'p1', ids: ['b', 'a'] }),
+      );
+      // Other-context section c keeps its absolute slot at index 2.
+      expect(next.ids).toEqual(['b', 'a', 'c']);
+    });
+
+    it('keeps interleaved cross-context sections in place', () => {
+      const start = stateWithSections([
+        makeSection({ id: 'a', contextId: 'p1' }),
+        makeSection({ id: 'x', contextId: 'p2' }),
+        makeSection({ id: 'b', contextId: 'p1' }),
+        makeSection({ id: 'y', contextId: 'p2' }),
+        makeSection({ id: 'c', contextId: 'p1' }),
+      ]);
+      const next = sectionReducer(
+        start,
+        updateSectionOrder({ contextId: 'p1', ids: ['c', 'b', 'a'] }),
+      );
+      // p1 slots (0, 2, 4) get reordered; p2 slots (1, 3) untouched.
+      expect(next.ids).toEqual(['c', 'x', 'b', 'y', 'a']);
+    });
+
+    it('returns the same reference when the order is unchanged', () => {
+      const start = stateWithSections([
+        makeSection({ id: 'a', contextId: 'p1' }),
+        makeSection({ id: 'b', contextId: 'p1' }),
+      ]);
+      const next = sectionReducer(
+        start,
+        updateSectionOrder({ contextId: 'p1', ids: ['a', 'b'] }),
+      );
+      expect(next).toBe(start);
+    });
+
+    it('ignores payload entries that no longer resolve to a context section', () => {
+      // Sync-replay scenario: a remote client deleted section 'b' while
+      // another reordered ['a','b','c'] → ['c','b','a']. Payload should
+      // be applied as if 'b' is absent, leaving slots that map to {a,c}.
+      const start = stateWithSections([
+        makeSection({ id: 'a', contextId: 'p1' }),
+        makeSection({ id: 'c', contextId: 'p1' }),
+      ]);
+      const next = sectionReducer(
+        start,
+        updateSectionOrder({ contextId: 'p1', ids: ['c', 'b', 'a'] }),
+      );
+      expect(next.ids).toEqual(['c', 'a']);
+    });
+
+    it('does not duplicate or wrap when payload is shorter than context slots', () => {
+      const start = stateWithSections([
+        makeSection({ id: 'a', contextId: 'p1' }),
+        makeSection({ id: 'b', contextId: 'p1' }),
+        makeSection({ id: 'c', contextId: 'p1' }),
+      ]);
+      // Partial payload: 'b' is moved to the first context-slot; the
+      // missing entries ('a', 'c') append in their original order so
+      // every section keeps a valid (and unique) slot.
+      const next = sectionReducer(
+        start,
+        updateSectionOrder({ contextId: 'p1', ids: ['b'] }),
+      );
+      expect(next.ids).toEqual(['b', 'a', 'c']);
+    });
+  });
+
+  describe('addTaskToSection (atomic placement)', () => {
+    it('appends the task to an empty target section', () => {
+      const start = stateWithSections([makeSection({ id: 's1', taskIds: [] })]);
+      const next = sectionReducer(
+        start,
+        addTaskToSection({
+          sectionId: 's1',
+          taskId: 't1',
+          afterTaskId: null,
+          sourceSectionId: null,
+        }),
+      );
+      expect(next.entities['s1']?.taskIds).toEqual(['t1']);
+    });
+
+    it('places the task after the anchor', () => {
+      const start = stateWithSections([
+        makeSection({ id: 's1', taskIds: ['a', 'b', 'c'] }),
+      ]);
+      const next = sectionReducer(
+        start,
+        addTaskToSection({
+          sectionId: 's1',
+          taskId: 'NEW',
+          afterTaskId: 'b',
+          sourceSectionId: null,
+        }),
+      );
+      expect(next.entities['s1']?.taskIds).toEqual(['a', 'b', 'NEW', 'c']);
+    });
+
+    it('places the task at the start when afterTaskId is null', () => {
+      const start = stateWithSections([makeSection({ id: 's1', taskIds: ['a', 'b'] })]);
+      const next = sectionReducer(
+        start,
+        addTaskToSection({
+          sectionId: 's1',
+          taskId: 'NEW',
+          afterTaskId: null,
+          sourceSectionId: null,
+        }),
+      );
+      expect(next.entities['s1']?.taskIds).toEqual(['NEW', 'a', 'b']);
+    });
+
+    it('strips from the explicit source when moving across sections', () => {
+      const start = stateWithSections([
+        makeSection({ id: 's1', taskIds: ['x', 't1', 'y'] }),
+        makeSection({ id: 's2', taskIds: [] }),
+      ]);
+      const next = sectionReducer(
+        start,
+        addTaskToSection({
+          sectionId: 's2',
+          taskId: 't1',
+          afterTaskId: null,
+          sourceSectionId: 's1',
+        }),
+      );
+      expect(next.entities['s1']?.taskIds).toEqual(['x', 'y']);
+      expect(next.entities['s2']?.taskIds).toEqual(['t1']);
+    });
+
+    it('moves within the same section without duplicating', () => {
+      const start = stateWithSections([
+        makeSection({ id: 's1', taskIds: ['a', 'b', 'c'] }),
+      ]);
+      const next = sectionReducer(
+        start,
+        addTaskToSection({
+          sectionId: 's1',
+          taskId: 'a',
+          afterTaskId: 'b',
+          sourceSectionId: 's1',
+        }),
+      );
+      expect(next.entities['s1']?.taskIds).toEqual(['b', 'a', 'c']);
+    });
+
+    it('does not touch other sections when sourceSectionId is null', () => {
+      // Local invariant says t1 should only be in s1, but the test simulates
+      // a stale duplicate (e.g. concurrent move). With explicit null source
+      // the reducer must NOT touch the duplicate — replay determinism.
+      const start = stateWithSections([
+        makeSection({ id: 's1', taskIds: ['t1'] }),
+        makeSection({ id: 's2', taskIds: [] }),
+      ]);
+      const next = sectionReducer(
+        start,
+        addTaskToSection({
+          sectionId: 's2',
+          taskId: 't1',
+          afterTaskId: null,
+          sourceSectionId: null,
+        }),
+      );
+      expect(next.entities['s1']?.taskIds).toEqual(['t1']);
+      expect(next.entities['s2']?.taskIds).toEqual(['t1']);
+    });
+
+    it('returns the same reference when nothing changes (target missing, no source)', () => {
+      const start = stateWithSections([makeSection({ id: 's1', taskIds: [] })]);
+      const next = sectionReducer(
+        start,
+        addTaskToSection({
+          sectionId: 'unknown',
+          taskId: 't1',
+          afterTaskId: null,
+          sourceSectionId: null,
+        }),
+      );
+      expect(next).toBe(start);
+    });
+  });
+
+  describe('removeTaskFromSection', () => {
+    it('strips the task from the named section only', () => {
+      const start = stateWithSections([
+        makeSection({ id: 's1', taskIds: ['t1', 't2'] }),
+        makeSection({ id: 's2', taskIds: ['t1', 't3'] }),
+      ]);
+      const next = sectionReducer(
+        start,
+        removeTaskFromSection({ sectionId: 's1', taskId: 't1' }),
+      );
+      expect(next.entities['s1']?.taskIds).toEqual(['t2']);
+      // Other sections untouched — caller is responsible for the right source.
+      expect(next.entities['s2']?.taskIds).toEqual(['t1', 't3']);
+    });
+
+    it('is a no-op when the section does not have the task', () => {
+      const start = stateWithSections([makeSection({ id: 's1', taskIds: ['t1'] })]);
+      const next = sectionReducer(
+        start,
+        removeTaskFromSection({ sectionId: 's1', taskId: 'absent' }),
+      );
+      expect(next).toBe(start);
+    });
+
+    it('is a no-op when the section is missing', () => {
+      const start = stateWithSections([makeSection({ id: 's1', taskIds: ['t1'] })]);
+      const next = sectionReducer(
+        start,
+        removeTaskFromSection({ sectionId: 'missing', taskId: 't1' }),
+      );
+      expect(next).toBe(start);
+    });
+  });
+});
diff --git a/src/app/features/section/store/section.reducer.ts b/src/app/features/section/store/section.reducer.ts
new file mode 100644
index 0000000000..3e92c67f91
--- /dev/null
+++ b/src/app/features/section/store/section.reducer.ts
@@ -0,0 +1,151 @@
+import { createReducer, on } from '@ngrx/store';
+import { createEntityAdapter, EntityAdapter, Update } from '@ngrx/entity';
+import * as SectionActions from './section.actions';
+import { Section, SectionState } from '../section.model';
+import { sanitizeSectionTitle } from '../section.util';
+import { loadAllData } from '../../../root-store/meta/load-all-data.action';
+import { moveItemAfterAnchor } from '../../work-context/store/work-context-meta.helper';
+
+export const SECTION_FEATURE_NAME = 'section';
+
+export const adapter: EntityAdapter<Section> = createEntityAdapter<Section>();
+
+export const initialSectionState: SectionState = adapter.getInitialState({
+  ids: [] as string[],
+});
+
+const removeTaskIdFromSection = (
+  section: Section,
+  taskId: string,
+): Update<Section> | null => {
+  if (!section.taskIds.includes(taskId)) return null;
+  return {
+    id: section.id,
+    changes: { taskIds: section.taskIds.filter((id) => id !== taskId) },
+  };
+};
+
+export const sectionReducer = createReducer(
+  initialSectionState,
+
+  on(SectionActions.addSection, (state, { section }) =>
+    adapter.addOne(
+      {
+        ...section,
+        title: sanitizeSectionTitle(section.title),
+        taskIds: section.taskIds ?? [],
+      },
+      state,
+    ),
+  ),
+
+  on(SectionActions.deleteSection, (state, { id }) => adapter.removeOne(id, state)),
+
+  on(SectionActions.updateSection, (state, { section }) => {
+    // Sanitize when title key is present (regardless of value type) so
+    // a malformed peer's `{ title: null }` cannot bypass the cap.
+    if (!Object.hasOwn(section.changes, 'title')) {
+      return adapter.updateOne(section, state);
+    }
+    return adapter.updateOne(
+      {
+        ...section,
+        changes: {
+          ...section.changes,
+          title: sanitizeSectionTitle(section.changes.title),
+        },
+      },
+      state,
+    );
+  }),
+
+  on(SectionActions.updateSectionOrder, (state, { contextId, ids }) => {
+    // Build the new context-section order, then splice into state.ids in
+    // place of context-matching slots. Other-context sections keep their
+    // absolute slot, so the global ids array stays stable across
+    // cross-context edits.
+    //
+    // Defensive: payload may be partial / out-of-date relative to local
+    // state (e.g. a remote client deleted a section while another
+    // reordered). We accept payload entries that still resolve to a
+    // section in this context, dedupe them, then append any context
+    // sections the payload missed (in their original relative order) so
+    // no section disappears or is duplicated.
+    const seen = new Set<string>();
+    const ordered: string[] = [];
+    for (const id of ids) {
+      if (seen.has(id)) continue;
+      const s = state.entities[id];
+      if (s && s.contextId === contextId) {
+        seen.add(id);
+        ordered.push(id);
+      }
+    }
+    for (const id of state.ids as string[]) {
+      const s = state.entities[id];
+      if (s && s.contextId === contextId && !seen.has(id)) {
+        ordered.push(id);
+      }
+    }
+
+    let cursor = 0;
+    let changed = false;
+    const next = (state.ids as string[]).map((id) => {
+      const s = state.entities[id];
+      if (!s || s.contextId !== contextId) return id;
+      const replacement = ordered[cursor++] ?? id;
+      if (replacement !== id) changed = true;
+      return replacement;
+    });
+    return changed ? { ...state, ids: next } : state;
+  }),
+
+  on(
+    SectionActions.addTaskToSection,
+    (state, { sectionId, taskId, afterTaskId, sourceSectionId }) => {
+      const updates: Update<Section>[] = [];
+
+      // Strip from the explicit source (if any). Replay produces the
+      // same result regardless of current state — `null` means "task
+      // wasn't in any section" and explicitly NOT a sweep request.
+      if (sourceSectionId && sourceSectionId !== sectionId) {
+        const src = state.entities[sourceSectionId];
+        if (src) {
+          const removal = removeTaskIdFromSection(src, taskId);
+          if (removal) updates.push(removal);
+        }
+      }
+
+      const target = state.entities[sectionId];
+      if (target) {
+        const newTaskIds = moveItemAfterAnchor(
+          taskId,
+          afterTaskId ?? null,
+          target.taskIds.includes(taskId) ? target.taskIds : [...target.taskIds, taskId],
+        );
+        updates.push({ id: sectionId, changes: { taskIds: newTaskIds } });
+      }
+
+      return updates.length ? adapter.updateMany(updates, state) : state;
+    },
+  ),
+
+  on(SectionActions.removeTaskFromSection, (state, { sectionId, taskId }) => {
+    const section = state.entities[sectionId];
+    if (!section) return state;
+    const removal = removeTaskIdFromSection(section, taskId);
+    return removal ? adapter.updateOne(removal, state) : state;
+  }),
+
+  on(loadAllData, (_state, { appDataComplete }) =>
+    // SYNC_IMPORT / BACKUP_IMPORT semantics: full state replacement.
+    // Fall back to the empty initial state when the payload omits
+    // `section` (legacy backups predate the feature) so we don't keep
+    // stale local sections after an explicit import.
+    appDataComplete.section
+      ? (appDataComplete.section as SectionState)
+      : initialSectionState,
+  ),
+);
+
+export const { selectAll } = adapter.getSelectors();
diff --git a/src/app/features/section/store/section.selectors.ts b/src/app/features/section/store/section.selectors.ts
new file mode 100644
index 0000000000..0c96dcf94a
--- /dev/null
+++ b/src/app/features/section/store/section.selectors.ts
@@ -0,0 +1,29 @@
+import { createFeatureSelector, createSelector } from '@ngrx/store';
+import { Section, SectionState } from '../section.model';
+import { selectAll, SECTION_FEATURE_NAME } from './section.reducer';
+
+export const selectSectionFeatureState =
+  createFeatureSelector<SectionState>(SECTION_FEATURE_NAME);
+
+export const selectAllSections = createSelector(selectSectionFeatureState, selectAll);
+
+/**
+ * Memoized selector grouping sections by contextId. A Map (not a plain
+ * object) is used so that a malicious sync peer cannot poison
+ * Object.prototype via a crafted contextId like "__proto__".
+ */
+export const selectSectionsByContextIdMap = createSelector(
+  selectAllSections,
+  (sections): Map<string, Section[]> => {
+    const map = new Map<string, Section[]>();
+    for (const s of sections) {
+      const arr = map.get(s.contextId);
+      if (arr) {
+        arr.push(s);
+      } else {
+        map.set(s.contextId, [s]);
+      }
+    }
+    return map;
+  },
+);
diff --git a/src/app/features/tasks/markdown-paste.service.ts b/src/app/features/tasks/markdown-paste.service.ts
index 355593bd70..580de6d7c3 100644
--- a/src/app/features/tasks/markdown-paste.service.ts
+++ b/src/app/features/tasks/markdown-paste.service.ts
@@ -15,6 +15,11 @@ import { GlobalConfigService } from '../config/global-config.service';
 import { DEFAULT_GLOBAL_CONFIG } from '../config/default-global-config.const';
 import { Task } from './task.model';
 
+// Anchored at line start: ATX header (#…) or list-item marker (-/* with
+// optional checkbox). One-shot regex that bails before invoking the full
+// parsers on plain-text pastes.
+const MARKDOWN_TASK_OR_HEADER_RE = /^(?:#{1,6}\s|\s*[-*]\s)/m;
+
 @Injectable({
   providedIn: 'root',
 })
@@ -186,6 +191,11 @@ export class MarkdownPasteService {
   }
 
   isMarkdownTaskList(text: string): boolean {
+    // Cheap pre-screen — bails out for plain-text pastes (the common
+    // case for Ctrl+V) before invoking the full parsers, which would
+    // otherwise scan the whole input even for 800KB of prose.
+    if (!MARKDOWN_TASK_OR_HEADER_RE.test(text)) return false;
+
     const parsedTasks = parseMarkdownTasks(text);
     return parsedTasks !== null && parsedTasks.length > 0;
   }
diff --git a/src/app/features/tasks/store/task.reducer.ts b/src/app/features/tasks/store/task.reducer.ts
index ab696ba757..5002299650 100644
--- a/src/app/features/tasks/store/task.reducer.ts
+++ b/src/app/features/tasks/store/task.reducer.ts
@@ -324,6 +324,24 @@ export const taskReducer = createReducer<TaskState>(
   }),
 
   on(moveSubTask, (state, { taskId, srcTaskId, targetTaskId, afterTaskId }) => {
+    // Guard against invalid moves (e.g. 'UNDONE' passed as ID) that may
+    // appear in older op-log entries. Also reject self-moves where the
+    // task being moved is its own src/target — that would put a task into
+    // its own subTaskIds.
+    if (
+      !state.entities[srcTaskId] ||
+      !state.entities[targetTaskId] ||
+      taskId === srcTaskId ||
+      taskId === targetTaskId
+    ) {
+      TaskLog.warn('Ignoring invalid moveSubTask action', {
+        taskId,
+        srcTaskId,
+        targetTaskId,
+      });
+      return state;
+    }
+
     // Prevent circular references (task becoming subtask of its own descendant)
     if (wouldCreateCircularReference(state, taskId, targetTaskId)) {
       TaskLog.err(
diff --git a/src/app/features/tasks/task-list/task-list.component.spec.ts b/src/app/features/tasks/task-list/task-list.component.spec.ts
index 7d44077c2e..05fd8195ee 100644
--- a/src/app/features/tasks/task-list/task-list.component.spec.ts
+++ b/src/app/features/tasks/task-list/task-list.component.spec.ts
@@ -1,6 +1,6 @@
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { TaskListComponent } from './task-list.component';
-import { provideMockStore } from '@ngrx/store/testing';
+import { MockStore, provideMockStore } from '@ngrx/store/testing';
 import { CdkDrag, CdkDropList } from '@angular/cdk/drag-drop';
 import { TaskService } from '../task.service';
 import { WorkContextService } from '../../work-context/work-context.service';
@@ -11,10 +11,14 @@ import { DropListService } from '../../../core-ui/drop-list/drop-list.service';
 import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { of } from 'rxjs';
 import { TaskWithSubTasks } from '../task.model';
+import { SectionService } from '../../section/section.service';
+import { moveSubTask } from '../store/task.actions';
 
 describe('TaskListComponent', () => {
   let component: TaskListComponent;
   let fixture: ComponentFixture<TaskListComponent>;
+  let sectionServiceMock: jasmine.SpyObj<SectionService>;
+  let store: MockStore;
 
   // Helper to create mock CdkDrag
   const createMockDrag = (task: { id: string; parentId: string | null }): CdkDrag =>
@@ -22,16 +26,23 @@ describe('TaskListComponent', () => {
       data: task,
     }) as unknown as CdkDrag;
 
-  // Helper to create mock CdkDropList with allTasks
+  // Helper to create mock CdkDropList with allTasks. listId defaults to
+  // 'PARENT' to mirror top-level task lists; pass 'SUB' for subtask lists.
   const createMockDrop = (
     listModelId: string,
     allTasks: Partial<TaskWithSubTasks>[] = [],
+    listId: 'PARENT' | 'SUB' = 'PARENT',
   ): CdkDropList =>
     ({
-      data: { listModelId, allTasks },
+      data: { listId, listModelId, allTasks },
     }) as unknown as CdkDropList;
 
   beforeEach(async () => {
+    sectionServiceMock = jasmine.createSpyObj<SectionService>('SectionService', [
+      'addTaskToSection',
+      'removeTaskFromSection',
+    ]);
+
     await TestBed.configureTestingModule({
       imports: [TaskListComponent, NoopAnimationsModule],
       providers: [
@@ -65,9 +76,13 @@ describe('TaskListComponent', () => {
             blockAniTrigger$: { next: () => {} },
           },
         },
+        { provide: SectionService, useValue: sectionServiceMock },
       ],
     }).compileComponents();
 
+    store = TestBed.inject(MockStore);
+    spyOn(store, 'dispatch').and.callThrough();
+
     fixture = TestBed.createComponent(TaskListComponent);
     component = fixture.componentInstance;
     // Set required inputs
@@ -128,7 +143,7 @@ describe('TaskListComponent', () => {
         const subtask = { id: 'sub1', parentId: 'parent1' };
         const drag = createMockDrag(subtask);
         // listModelId is the parent task ID (subtask list)
-        const drop = createMockDrop('parent1', [{ id: 'sub1' }, { id: 'sub2' }]);
+        const drop = createMockDrop('parent1', [{ id: 'sub1' }, { id: 'sub2' }], 'SUB');
         expect(component.enterPredicate(drag, drop)).toBe(true);
       });
 
@@ -136,9 +151,17 @@ describe('TaskListComponent', () => {
         const subtask = { id: 'sub1', parentId: 'parent1' };
         const drag = createMockDrag(subtask);
         // Another task ID (not in PARENT_ALLOWED_LISTS)
-        const drop = createMockDrop('parent2', [{ id: 'sub3' }]);
+        const drop = createMockDrop('parent2', [{ id: 'sub3' }], 'SUB');
         expect(component.enterPredicate(drag, drop)).toBe(true);
       });
+
+      it('should block subtask from dropping into a section drop-list', () => {
+        const subtask = { id: 'sub1', parentId: 'parent1' };
+        const drag = createMockDrag(subtask);
+        // Section drop-lists render with listId='PARENT' and a section id.
+        const drop = createMockDrop('section-abc', [], 'PARENT');
+        expect(component.enterPredicate(drag, drop)).toBe(false);
+      });
     });
 
     describe('parent tasks', () => {
@@ -173,10 +196,18 @@ describe('TaskListComponent', () => {
       it('should block parent task from dropping to subtask list', () => {
         const task = { id: 'task1', parentId: null };
         const drag = createMockDrag(task);
-        // Task ID = subtask list
-        const drop = createMockDrop('some-task-id', []);
+        // Task ID listed as a subtask drop-list (listId='SUB').
+        const drop = createMockDrop('some-task-id', [], 'SUB');
         expect(component.enterPredicate(drag, drop)).toBe(false);
       });
+
+      it('should allow parent task to drop into a section drop-list', () => {
+        const task = { id: 'task1', parentId: null };
+        const drag = createMockDrag(task);
+        // Section drop-lists are listId='PARENT' with an arbitrary section id.
+        const drop = createMockDrop('section-xyz', [], 'PARENT');
+        expect(component.enterPredicate(drag, drop)).toBe(true);
+      });
     });
 
     describe('blocked lists', () => {
@@ -286,4 +317,106 @@ describe('TaskListComponent', () => {
       });
     });
   });
+
+  // _move() routes drag drops to the correct dispatch path. The crux of the
+  // section feature: a non-reserved listModelId must only be treated as a
+  // section when listId === 'PARENT'; subtask drop-lists ('SUB') also use
+  // non-reserved ids (parent task ids) and must fall through to moveSubTask.
+  describe('_move dispatch routing', () => {
+    // Cast to any to call the private method directly.
+    const callMove = (
+      taskId: string,
+      src: string,
+      target: string,
+      srcListId: 'PARENT' | 'SUB',
+      targetListId: 'PARENT' | 'SUB',
+      newOrderedIds: string[] = [taskId],
+    ): void => {
+      (
+        component as unknown as {
+          _move: (
+            t: string,
+            s: string,
+            tg: string,
+            sl: 'PARENT' | 'SUB',
+            tl: 'PARENT' | 'SUB',
+            ids: string[],
+          ) => void;
+        }
+      )._move(taskId, src, target, srcListId, targetListId, newOrderedIds);
+    };
+
+    it('routes a subtask drop into another subtask list to moveSubTask (not addTaskToSection)', () => {
+      // Both src and target are subtask lists with parent task ids as listModelId.
+      callMove('sub1', 'parentA', 'parentB', 'SUB', 'SUB');
+
+      expect(sectionServiceMock.addTaskToSection).not.toHaveBeenCalled();
+      const dispatchedAction = (store.dispatch as jasmine.Spy).calls.mostRecent()
+        .args[0] as ReturnType<typeof moveSubTask>;
+      expect(dispatchedAction.type).toBe(moveSubTask.type);
+      expect(dispatchedAction.taskId).toBe('sub1');
+      expect(dispatchedAction.srcTaskId).toBe('parentA');
+      expect(dispatchedAction.targetTaskId).toBe('parentB');
+    });
+
+    it('routes a parent drop into a section drop-list (PARENT + non-reserved id) to addTaskToSection', () => {
+      callMove('task1', 'UNDONE', 'section-abc', 'PARENT', 'PARENT');
+
+      const args = sectionServiceMock.addTaskToSection.calls.mostRecent().args;
+      expect(args[0]).toBe('section-abc');
+      expect(args[1]).toBe('task1');
+      // Source was a reserved list (UNDONE), so sourceSectionId is null.
+      expect(args[3]).toBeNull();
+    });
+
+    it('passes the explicit sourceSectionId when dragging between sections', () => {
+      callMove('task1', 'section-from', 'section-to', 'PARENT', 'PARENT');
+
+      const args = sectionServiceMock.addTaskToSection.calls.mostRecent().args;
+      expect(args[0]).toBe('section-to');
+      expect(args[1]).toBe('task1');
+      expect(args[3]).toBe('section-from');
+    });
+
+    it('computes afterTaskId from newOrderedIds (anchor: previous sibling)', () => {
+      // newOrderedIds is the post-drop order of the destination list.
+      // getAnchorFromDragDrop returns the id immediately preceding `taskId`,
+      // which is what placeTaskAfterAnchor uses to position the move.
+      callMove('task1', 'UNDONE', 'section-x', 'PARENT', 'PARENT', [
+        'before',
+        'task1',
+        'after',
+      ]);
+
+      const args = sectionServiceMock.addTaskToSection.calls.mostRecent().args;
+      expect(args[0]).toBe('section-x');
+      expect(args[1]).toBe('task1');
+      expect(args[2]).toBe('before');
+      expect(args[3]).toBeNull();
+    });
+
+    it('passes null afterTaskId when dropped at the start of a section', () => {
+      callMove('task1', 'UNDONE', 'section-x', 'PARENT', 'PARENT', ['task1', 'after']);
+
+      const args = sectionServiceMock.addTaskToSection.calls.mostRecent().args;
+      expect(args[2]).toBeNull();
+    });
+
+    it('routes a section -> no-section drag to removeTaskFromSection', () => {
+      callMove('task1', 'section-from', 'UNDONE', 'PARENT', 'PARENT');
+
+      expect(sectionServiceMock.removeTaskFromSection).toHaveBeenCalledWith(
+        'section-from',
+        'task1',
+      );
+      expect(sectionServiceMock.addTaskToSection).not.toHaveBeenCalled();
+    });
+
+    it('does NOT route reserved-list drops (DONE/UNDONE/BACKLOG) as section moves', () => {
+      callMove('task1', 'UNDONE', 'DONE', 'PARENT', 'PARENT');
+
+      expect(sectionServiceMock.addTaskToSection).not.toHaveBeenCalled();
+      expect(sectionServiceMock.removeTaskFromSection).not.toHaveBeenCalled();
+    });
+  });
 });
diff --git a/src/app/features/tasks/task-list/task-list.component.ts b/src/app/features/tasks/task-list/task-list.component.ts
index 90fe8daa5f..7d87a13ee1 100644
--- a/src/app/features/tasks/task-list/task-list.component.ts
+++ b/src/app/features/tasks/task-list/task-list.component.ts
@@ -25,6 +25,7 @@ import {
   moveProjectTaskToBacklogList,
   moveProjectTaskToRegularList,
 } from '../../project/store/project.actions';
+import { SectionService } from '../../section/section.service';
 import { moveSubTask } from '../store/task.actions';
 import { TaskSharedActions } from '../../../root-store/meta/task-shared.actions';
 import { WorkContextService } from '../../work-context/work-context.service';
@@ -46,9 +47,32 @@ import { dragDelayForTouch } from '../../../util/input-intent';
 
 export type TaskListId = 'PARENT' | 'SUB';
 export type ListModelId = DropListModelSource | string;
+
+// Reserved list ids — anything else in a PARENT-level list is treated as a
+// section id. Subtask drop-lists (listId === 'SUB') use parent task ids as
+// their listModelId, so the section check must additionally key on listId.
+//
+// RESERVED_LIST_IDS includes LATER_TODAY because section detection runs in
+// _move() AFTER the LATER_TODAY short-circuit; treating LATER_TODAY as a
+// section would otherwise create one if the short-circuit ever moves.
+// PARENT_ALLOWED_LISTS deliberately omits LATER_TODAY — enterPredicate must
+// reject parent drops onto LATER_TODAY at the drag layer (see line ~190).
+//
+// `satisfies DropListModelSource[]` validates each entry against the union
+// (catches typos / removed variants) without narrowing the Set's value
+// type, which would force a cast at every `.has(target as string)` call.
+const RESERVED_LIST_IDS = new Set<string>([
+  'DONE',
+  'UNDONE',
+  'OVERDUE',
+  'BACKLOG',
+  'LATER_TODAY',
+  'ADD_TASK_PANEL',
+] satisfies DropListModelSource[]);
 const PARENT_ALLOWED_LISTS = ['DONE', 'UNDONE', 'OVERDUE', 'BACKLOG', 'ADD_TASK_PANEL'];
 
 export interface DropModelDataForList {
+  listId: TaskListId;
   listModelId: ListModelId;
   allTasks: TaskWithSubTasks[];
   filteredTasks: TaskWithSubTasks[];
@@ -73,6 +97,7 @@ export class TaskListComponent implements OnDestroy, AfterViewInit {
   private _taskService = inject(TaskService);
   private _workContextService = inject(WorkContextService);
   private _store = inject(Store);
+  private _sectionService = inject(SectionService);
   private _issueService = inject(IssueService);
   private _taskViewCustomizerService = inject(TaskViewCustomizerService);
   private _scheduleExternalDragService = inject(ScheduleExternalDragService);
@@ -99,6 +124,7 @@ export class TaskListComponent implements OnDestroy, AfterViewInit {
   currentTaskId = toSignal(this._taskService.currentTaskId$);
   dropModelDataForList = computed<DropModelDataForList>(() => {
     return {
+      listId: this.listId(),
       listModelId: this.listModelId(),
       allTasks: this.tasks(),
       filteredTasks: this.filteredTasks(),
@@ -150,6 +176,7 @@ export class TaskListComponent implements OnDestroy, AfterViewInit {
     // TODO this gets called very often for nested lists. Maybe there are possibilities to optimize
     const task = drag.data;
     const targetModelId = drop.data.listModelId;
+    const targetListId = drop.data.listId;
     const isSubtask = !!task.parentId;
 
     if (targetModelId === 'OVERDUE' || targetModelId === 'LATER_TODAY') {
@@ -173,18 +200,38 @@ export class TaskListComponent implements OnDestroy, AfterViewInit {
         return false;
       }
 
-      // Subtasks can move within subtask lists (where listModelId is a task ID)
-      if (!PARENT_ALLOWED_LISTS.includes(targetModelId)) {
+      // Subtasks may drop into another subtask list (listId === 'SUB' with a
+      // task id as listModelId). Reject section drop-lists (listId === 'PARENT'
+      // with a non-reserved id) — section.taskIds is parent-only.
+      if (targetListId === 'SUB' && !PARENT_ALLOWED_LISTS.includes(targetModelId)) {
         return true;
       }
       return false;
     }
 
-    // Parent tasks: allow drops to PARENT_ALLOWED_LISTS
+    // Parent tasks: allow drops to PARENT_ALLOWED_LISTS or to sections (parent-level
+    // lists with a non-reserved id). Subtask drop-lists (listId === 'SUB') are
+    // rejected so a top-level task can't be nested into another task's subtree.
+    const srcModelId = drag.dropContainer?.data?.listModelId;
+    const srcListIdRaw = drag.dropContainer?.data?.listId;
+    const isSrcSection = srcListIdRaw === 'PARENT' && !RESERVED_LIST_IDS.has(srcModelId);
+
     if (PARENT_ALLOWED_LISTS.includes(targetModelId)) {
+      // Reject section → BACKLOG: _move() dispatches `removeTaskFromSection`
+      // and returns without dispatching `moveProjectTaskToBacklogList`, so
+      // the task disappears from the section but is never added to backlog.
+      // Force users to first move section → today, then today → backlog.
+      if (targetModelId === 'BACKLOG' && isSrcSection) return false;
       return true;
     }
-    return false;
+    if (targetListId !== 'PARENT') return false;
+
+    // Target is a section. Reject drops from BACKLOG: _move() treats this as
+    // a pure section-add and never removes the task from project.backlogTaskIds,
+    // leaving it in both lists. Force users to first move backlog → today.
+    if (srcModelId === 'BACKLOG') return false;
+
+    return true;
   };
 
   async drop(
@@ -272,6 +319,8 @@ export class TaskListComponent implements OnDestroy, AfterViewInit {
       draggedTask.id,
       srcListData.listModelId,
       targetListData.listModelId,
+      srcListData.listId,
+      targetListData.listId,
       newIds.map((p) => p.id),
     );
 
@@ -297,6 +346,8 @@ export class TaskListComponent implements OnDestroy, AfterViewInit {
     taskId: string,
     src: DropListModelSource | string,
     target: DropListModelSource | string,
+    srcListId: TaskListId,
+    targetListId: TaskListId,
     newOrderedIds: string[],
   ): void {
     const isSrcRegularList = src === 'DONE' || src === 'UNDONE';
@@ -308,6 +359,36 @@ export class TaskListComponent implements OnDestroy, AfterViewInit {
       return;
     }
 
+    if (workContextId) {
+      // Section drop-lists are PARENT-level lists whose listModelId is a
+      // section id (anything that isn't one of the reserved keywords).
+      // Subtask drop-lists (listId === 'SUB') also use non-reserved
+      // listModelIds (parent task ids) — those must NOT be treated as
+      // sections, otherwise a subtask drag would dispatch addTaskToSection
+      // instead of moveSubTask.
+      const targetIsSection = targetListId === 'PARENT' && !RESERVED_LIST_IDS.has(target);
+      const srcIsSection = srcListId === 'PARENT' && !RESERVED_LIST_IDS.has(src);
+
+      if (targetIsSection) {
+        const afterTaskId = getAnchorFromDragDrop(taskId, newOrderedIds);
+        // Pass the source section explicitly so replay is deterministic.
+        // `null` means the task wasn't in a section before the drag.
+        const sourceSectionId = srcIsSection ? (src as string) : null;
+        this._sectionService.addTaskToSection(
+          target as string,
+          taskId,
+          afterTaskId,
+          sourceSectionId,
+        );
+        return;
+      }
+      if (srcIsSection) {
+        // Dragged out of a section into the no-section area.
+        this._sectionService.removeTaskFromSection(src as string, taskId);
+        return;
+      }
+    }
+
     if (isSrcRegularList && isTargetRegularList) {
       // move inside today
       const workContextType = this._workContextService
diff --git a/src/app/features/tasks/task/task.component.ts b/src/app/features/tasks/task/task.component.ts
index 60fb38faa6..6bd0c4c2bd 100644
--- a/src/app/features/tasks/task/task.component.ts
+++ b/src/app/features/tasks/task/task.component.ts
@@ -100,6 +100,7 @@ import { TaskFocusService } from '../task-focus.service';
   /* eslint-disable @typescript-eslint/naming-convention*/
   host: {
     '[id]': 'taskIdWithPrefix()',
+    '[attr.data-task-id]': 'task().id',
     '[tabindex]': '1',
     '[class.isDone]': 'task().isDone',
     '[class.isCurrent]': 'isCurrent()',
diff --git a/src/app/features/work-view/work-view.component.html b/src/app/features/work-view/work-view.component.html
index 53fcd1c796..0ee267c3c6 100644
--- a/src/app/features/work-view/work-view.component.html
+++ b/src/app/features/work-view/work-view.component.html
@@ -135,6 +135,80 @@
                 ></task-list>
               </collapsible>
             }
+          } @else if (sections().length && !customizerService.isCustomized()) {
+            @let bySection = undoneTasksBySection();
+            <div
+              class="sections-wrapper"
+              cdkDropList
+              [cdkDropListEnterPredicate]="acceptSectionDragOnly"
+              (cdkDropListDropped)="dropSection($event)"
+            >
+              <div class="no-section">
+                <task-list
+                  [tasks]="bySection.noSection"
+                  [listId]="'PARENT'"
+                  [listModelId]="'UNDONE'"
+                  [noTasksMsg]="
+                    undoneTasks().length
+                      ? (T.WW.NO_TASKS_IN_MAIN_LIST | translate)
+                      : undefined
+                  "
+                ></task-list>
+              </div>
+              @for (section of sections(); track section.id) {
+                <div
+                  class="section-container"
+                  cdkDrag
+                  [cdkDragData]="section"
+                  [cdkDragLockAxis]="'y'"
+                >
+                  <collapsible
+                    [title]="section.title"
+                    [isIconBefore]="true"
+                    [isExpanded]="true"
+                  >
+                    <ng-container actions>
+                      <div
+                        class="drag-handle"
+                        cdkDragHandle
+                      >
+                        <mat-icon>drag_indicator</mat-icon>
+                      </div>
+                      <button
+                        mat-icon-button
+                        [matMenuTriggerFor]="sectionMenu"
+                        [attr.aria-label]="T.WW.SECTION_OPTIONS | translate"
+                        (click)="$event.stopPropagation()"
+                      >
+                        <mat-icon>more_vert</mat-icon>
+                      </button>
+                      <mat-menu #sectionMenu="matMenu">
+                        <button
+                          mat-menu-item
+                          (click)="editSection(section.id, section.title)"
+                        >
+                          <mat-icon>edit</mat-icon>
+                          {{ T.G.EDIT | translate }}
+                        </button>
+                        <button
+                          mat-menu-item
+                          (click)="deleteSection(section.id)"
+                        >
+                          <mat-icon>delete</mat-icon>
+                          {{ T.G.DELETE | translate }}
+                        </button>
+                      </mat-menu>
+                    </ng-container>
+
+                    <task-list
+                      [tasks]="bySection.dict[section.id]"
+                      [listId]="'PARENT'"
+                      [listModelId]="section.id"
+                    ></task-list>
+                  </collapsible>
+                </div>
+              }
+            </div>
           } @else {
             <task-list
               class="tour-undoneList"
diff --git a/src/app/features/work-view/work-view.component.scss b/src/app/features/work-view/work-view.component.scss
index acd692560f..ae70edac06 100644
--- a/src/app/features/work-view/work-view.component.scss
+++ b/src/app/features/work-view/work-view.component.scss
@@ -279,3 +279,40 @@ finish-day-btn,
 .repeat-cfg-list {
   padding: var(--s-half);
 }
+
+.no-section,
+.section-container {
+  margin-bottom: var(--s3);
+}
+
+// Section header layout: title left, actions right.
+.section-container {
+  ::ng-deep .collapsible-header {
+    justify-content: space-between;
+  }
+
+  ::ng-deep .collapsible-title {
+    text-align: left;
+    // ensure title takes available space to push actions to right
+    flex-grow: 1;
+  }
+
+  .drag-handle {
+    display: inline-flex;
+    align-items: center;
+    cursor: move;
+    margin-right: var(--s);
+    color: var(--text-color-secondary);
+  }
+
+  // Style the action-slot menu trigger only — narrow scope avoids leaking
+  // resets into <task-list> descendants. The collapsible projects content
+  // via `[actions]`, which lands inside `.collapsible-header`; the next
+  // selector matches an icon-button that's a direct child of that header.
+  ::ng-deep > collapsible > .collapsible-header > button[mat-icon-button] {
+    background: transparent;
+    box-shadow: none;
+    color: var(--text-color-secondary);
+    border: none;
+  }
+}
diff --git a/src/app/features/work-view/work-view.component.spec.ts b/src/app/features/work-view/work-view.component.spec.ts
index e6ba48c6b3..f225bf9079 100644
--- a/src/app/features/work-view/work-view.component.spec.ts
+++ b/src/app/features/work-view/work-view.component.spec.ts
@@ -109,6 +109,7 @@ describe('WorkViewComponent', () => {
               estimateRemainingToday$: of(0),
               workingToday$: of(0),
               isTodayList$: of(false),
+              activeWorkContextId$: of(null),
               activeWorkContextTypeAndId$: of({
                 activeType: 'TAG',
                 activeId: 'TODAY',
diff --git a/src/app/features/work-view/work-view.component.ts b/src/app/features/work-view/work-view.component.ts
index 9b91aca37e..e85155d497 100644
--- a/src/app/features/work-view/work-view.component.ts
+++ b/src/app/features/work-view/work-view.component.ts
@@ -3,6 +3,7 @@ import {
   ChangeDetectorRef,
   Component,
   computed,
+  DestroyRef,
   effect,
   ElementRef,
   afterNextRender,
@@ -13,7 +14,12 @@ import {
   signal,
   ViewChild,
 } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { MatMenuModule } from '@angular/material/menu';
+
 import { TaskService } from '../tasks/task.service';
+import { DialogConfirmComponent } from '../../ui/dialog-confirm/dialog-confirm.component';
+import { DialogPromptComponent } from '../../ui/dialog-prompt/dialog-prompt.component';
 import { expandAnimation, expandFadeAnimation } from '../../ui/animations/expand.ani';
 import { LayoutService } from '../../core-ui/layout/layout.service';
 import { TakeABreakService } from '../take-a-break/take-a-break.service';
@@ -30,14 +36,24 @@ import {
 } from 'rxjs';
 import { TaskWithSubTasks } from '../tasks/task.model';
 import { delay, filter, map, observeOn, switchMap } from 'rxjs/operators';
+import { of } from 'rxjs';
 import { fadeAnimation } from '../../ui/animations/fade.ani';
 import { T } from '../../t.const';
 import { workViewProjectChangeAnimation } from '../../ui/animations/work-view-project-change.ani';
 import { WorkContextService } from '../work-context/work-context.service';
 import { ProjectService } from '../project/project.service';
 import { TaskViewCustomizerService } from '../task-view-customizer/task-view-customizer.service';
-import { toSignal } from '@angular/core/rxjs-interop';
-import { CdkDropListGroup } from '@angular/cdk/drag-drop';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { SectionService } from '../section/section.service';
+import { Section } from '../section/section.model';
+import {
+  CdkDrag,
+  CdkDragDrop,
+  CdkDragHandle,
+  CdkDropList,
+  CdkDropListGroup,
+  moveItemInArray,
+} from '@angular/cdk/drag-drop';
 import { CdkScrollable } from '@angular/cdk/scrolling';
 import { MatTooltip } from '@angular/material/tooltip';
 import { MatIcon } from '@angular/material/icon';
@@ -82,6 +98,9 @@ import { recordSearchNavDebug } from '../../util/search-nav-debug';
   changeDetection: ChangeDetectionStrategy.OnPush,
   imports: [
     CdkDropListGroup,
+    CdkDropList,
+    CdkDrag,
+    CdkDragHandle,
     CdkScrollable,
     MatTooltip,
     MatIcon,
@@ -95,6 +114,7 @@ import { recordSearchNavDebug } from '../../util/search-nav-debug';
     TranslatePipe,
     CollapsibleComponent,
     CommonModule,
+    MatMenuModule,
     FinishDayBtnComponent,
     ScheduledDateGroupPipe,
     RepeatCfgPreviewComponent,
@@ -107,6 +127,7 @@ export class WorkViewComponent implements OnInit, OnDestroy {
   taskService = inject(TaskService);
   takeABreakService = inject(TakeABreakService);
   layoutService = inject(LayoutService);
+  sectionService = inject(SectionService);
   customizerService = inject(TaskViewCustomizerService);
   workContextService = inject(WorkContextService);
   private _activatedRoute = inject(ActivatedRoute);
@@ -115,6 +136,8 @@ export class WorkViewComponent implements OnInit, OnDestroy {
   private _store = inject(Store);
   private _snackService = inject(SnackService);
   private _globalConfigService = inject(GlobalConfigService);
+  private _matDialog = inject(MatDialog);
+  private _destroyRef = inject(DestroyRef);
 
   isFinishDayEnabled = computed(
     () => this._globalConfigService.appFeatures().isFinishDayEnabled,
@@ -170,6 +193,48 @@ export class WorkViewComponent implements OnInit, OnDestroy {
       !this.customizerService.isCustomized() && this.repeatCfgsForContext().length > 0,
   );
 
+  // Section Logic
+  sections = toSignal(
+    this.workContextService.activeWorkContextId$.pipe(
+      switchMap((id) =>
+        id
+          ? this.sectionService.getSectionsByContextId$(id)
+          : of([] as readonly Section[]),
+      ),
+    ),
+    { initialValue: [] as readonly Section[] },
+  );
+
+  undoneTasksBySection = computed(() => {
+    const tasks = this.undoneTasks();
+    const sections = this.sections();
+
+    if (!sections.length) {
+      return { dict: {} as Record<string, TaskWithSubTasks[]>, noSection: tasks };
+    }
+
+    // Build sectionId-by-taskId in O(m) where m = total taskIds across sections.
+    const sectionByTaskId = new Map<string, string>();
+    for (const s of sections) {
+      for (const tId of s.taskIds ?? []) sectionByTaskId.set(tId, s.id);
+    }
+
+    const dict: Record<string, TaskWithSubTasks[]> = {};
+    for (const s of sections) dict[s.id] = [];
+    const noSection: TaskWithSubTasks[] = [];
+
+    for (const task of tasks) {
+      const sId = sectionByTaskId.get(task.id);
+      if (sId) {
+        dict[sId].push(task);
+      } else {
+        noSection.push(task);
+      }
+    }
+
+    return { dict, noSection };
+  });
+
   isShowOverduePanel = computed(
     () => this.isOnTodayList() && this.overdueTasks().length > 0,
   );
@@ -324,6 +389,39 @@ export class WorkViewComponent implements OnInit, OnDestroy {
     this.layoutService.isWorkViewScrolled.set(false);
   }
 
+  deleteSection(id: string): void {
+    this._matDialog
+      .open(DialogConfirmComponent, {
+        data: {
+          message: T.CONFIRM.DELETE_SECTION,
+        },
+      })
+      .afterClosed()
+      .pipe(takeUntilDestroyed(this._destroyRef))
+      .subscribe((isConfirm: boolean) => {
+        if (isConfirm) {
+          this.sectionService.deleteSection(id);
+        }
+      });
+  }
+
+  editSection(id: string, title: string): void {
+    this._matDialog
+      .open(DialogPromptComponent, {
+        data: {
+          placeholder: T.WW.ADD_SECTION_TITLE,
+          txtValue: title,
+        },
+      })
+      .afterClosed()
+      .pipe(takeUntilDestroyed(this._destroyRef))
+      .subscribe((newTitle: string | undefined) => {
+        if (newTitle?.trim()) {
+          this.sectionService.updateSection(id, { title: newTitle });
+        }
+      });
+  }
+
   resetBreakTimer(): void {
     this.takeABreakService.resetTimer();
   }
@@ -355,6 +453,23 @@ export class WorkViewComponent implements OnInit, OnDestroy {
     );
   }
 
+  // Reject task drags into the section-reorder list (cdkDropListGroup
+  // shares targets). `contextType` is section-exclusive.
+  acceptSectionDragOnly = (drag: CdkDrag): boolean => {
+    const data = drag.data as Section | undefined;
+    return !!data && 'contextType' in data;
+  };
+
+  dropSection(event: CdkDragDrop<Section[]>): void {
+    if (event.previousIndex === event.currentIndex) return;
+    const contextId = this.workContextService.activeWorkContextId;
+    if (!contextId) return;
+
+    const ids = this.sections().map((s) => s.id);
+    moveItemInArray(ids, event.previousIndex, event.currentIndex);
+    this.sectionService.updateSectionOrder(contextId, ids);
+  }
+
   private _initScrollTracking(): void {
     this._subs.add(
       this.upperContainerScroll$.subscribe(({ target }) => {
diff --git a/src/app/imex/sync/sync.const.ts b/src/app/imex/sync/sync.const.ts
index 7713dd7ee0..718006c818 100644
--- a/src/app/imex/sync/sync.const.ts
+++ b/src/app/imex/sync/sync.const.ts
@@ -1,3 +1,4 @@
+import { initialSectionState } from '../../features/section/store/section.reducer';
 import { initialProjectState } from '../../features/project/store/project.reducer';
 import { initialTaskState } from '../../features/tasks/store/task.reducer';
 import { initialTagState } from '../../features/tag/store/tag.reducer';
@@ -67,6 +68,7 @@ export const DEFAULT_APP_BASE_DATA: AppBaseData = {
   },
   taskRepeatCfg: initialTaskRepeatCfgState,
   note: initialNoteState,
+  section: initialSectionState,
 
   metric: initialMetricState,
 };
diff --git a/src/app/imex/sync/sync.model.ts b/src/app/imex/sync/sync.model.ts
index f872c20a63..45a7693e9b 100644
--- a/src/app/imex/sync/sync.model.ts
+++ b/src/app/imex/sync/sync.model.ts
@@ -13,6 +13,7 @@ import { PlannerState } from '../../features/planner/store/planner.reducer';
 import { IssueProviderState } from '../../features/issue/issue.model';
 import { BoardsState } from '../../features/boards/store/boards.reducer';
 import { MenuTreeState } from '../../features/menu-tree/store/menu-tree.model';
+import { SectionState } from '../../features/section/section.model';
 
 export interface AppBaseWithoutLastSyncModelChange {
   project: ProjectState;
@@ -30,6 +31,7 @@ export interface AppBaseWithoutLastSyncModelChange {
   tag: TagState;
   simpleCounter: SimpleCounterState;
   taskRepeatCfg: TaskRepeatCfgState;
+  section: SectionState;
 }
 
 export interface AppMainFileNoRevsData extends AppBaseWithoutLastSyncModelChange {
diff --git a/src/app/op-log/backup/state-snapshot.service.ts b/src/app/op-log/backup/state-snapshot.service.ts
index 4a24c515c0..76bff2111e 100644
--- a/src/app/op-log/backup/state-snapshot.service.ts
+++ b/src/app/op-log/backup/state-snapshot.service.ts
@@ -18,6 +18,7 @@ import { selectSimpleCounterFeatureState } from '../../features/simple-counter/s
 import { selectTagFeatureState } from '../../features/tag/store/tag.reducer';
 import { selectTaskFeatureState } from '../../features/tasks/store/task.selectors';
 import { selectTaskRepeatCfgFeatureState } from '../../features/task-repeat-cfg/store/task-repeat-cfg.selectors';
+import { selectSectionFeatureState } from '../../features/section/store/section.selectors';
 import { selectTimeTrackingState } from '../../features/time-tracking/store/time-tracking.selectors';
 import { environment } from '../../../environments/environment';
 import { ArchiveModel } from '../../features/time-tracking/time-tracking.model';
@@ -108,6 +109,7 @@ export class StateSnapshotService {
         this._store.select(selectPluginUserDataFeatureState),
         this._store.select(selectPluginMetadataFeatureState),
         this._store.select(selectReminderFeatureState),
+        this._store.select(selectSectionFeatureState),
       ]).pipe(first()),
     );
 
@@ -128,6 +130,7 @@ export class StateSnapshotService {
       pluginUserData,
       pluginMetadata,
       reminders,
+      section,
     ] = ngRxData;
 
     return {
@@ -153,6 +156,7 @@ export class StateSnapshotService {
       pluginUserData,
       pluginMetadata,
       reminders,
+      section,
       archiveYoung,
       archiveOld,
     };
@@ -176,7 +180,8 @@ export class StateSnapshotService {
     let simpleCounter: unknown,
       taskRepeatCfg: unknown,
       menuTree: unknown,
-      timeTracking: unknown;
+      timeTracking: unknown,
+      section: unknown;
     let pluginUserData: unknown, pluginMetadata: unknown, reminders: unknown;
 
     // Subscribe synchronously to get current values
@@ -244,6 +249,10 @@ export class StateSnapshotService {
       .select(selectReminderFeatureState)
       .pipe(first())
       .subscribe((v) => (reminders = v));
+    this._store
+      .select(selectSectionFeatureState)
+      .pipe(first())
+      .subscribe((v) => (section = v));
 
     return {
       task: {
@@ -268,6 +277,7 @@ export class StateSnapshotService {
       pluginUserData,
       pluginMetadata,
       reminders,
+      section,
     };
   }
 
diff --git a/src/app/op-log/core/action-types.enum.spec.ts b/src/app/op-log/core/action-types.enum.spec.ts
index c8696c8c0c..a96c73e050 100644
--- a/src/app/op-log/core/action-types.enum.spec.ts
+++ b/src/app/op-log/core/action-types.enum.spec.ts
@@ -12,8 +12,8 @@ describe('ActionType enum', () => {
   const enumValues = Object.values(ActionType) as string[];
   const mappingKeys = Object.keys(ACTION_TYPE_TO_CODE);
 
-  it('should have exactly 136 members', () => {
-    expect(enumValues.length).toBe(136);
+  it('should have exactly 142 members', () => {
+    expect(enumValues.length).toBe(142);
   });
 
   it('should have 1:1 correspondence with ACTION_TYPE_TO_CODE', () => {
diff --git a/src/app/op-log/core/action-types.enum.ts b/src/app/op-log/core/action-types.enum.ts
index df832efdb1..e08227fd8f 100644
--- a/src/app/op-log/core/action-types.enum.ts
+++ b/src/app/op-log/core/action-types.enum.ts
@@ -132,6 +132,14 @@ export enum ActionType {
   REPEAT_CFG_DELETE_INSTANCE = '[TaskRepeatCfg] Delete Single Instance',
   REPEAT_CFG_UPSERT = '[TaskRepeatCfg] Upsert TaskRepeatCfg',
 
+  // Section actions (S)
+  SECTION_ADD = '[Section] Add Section',
+  SECTION_DELETE = '[Section] Delete Section',
+  SECTION_UPDATE = '[Section] Update Section',
+  SECTION_UPDATE_ORDER = '[Section] Update Section Order',
+  SECTION_ADD_TASK = '[Section] Add Task to Section',
+  SECTION_REMOVE_TASK = '[Section] Remove Task from Section',
+
   // SimpleCounter actions (S)
   COUNTER_ADD = '[SimpleCounter] Add SimpleCounter',
   COUNTER_UPDATE = '[SimpleCounter] Update SimpleCounter',
diff --git a/src/app/op-log/core/types/backup.types.ts b/src/app/op-log/core/types/backup.types.ts
index 46a3e2cacd..46b4f96638 100644
--- a/src/app/op-log/core/types/backup.types.ts
+++ b/src/app/op-log/core/types/backup.types.ts
@@ -21,6 +21,7 @@ export interface AppStateSnapshot {
   pluginUserData: unknown;
   pluginMetadata: unknown;
   reminders: unknown;
+  section: unknown;
   archiveYoung: ArchiveModel;
   archiveOld: ArchiveModel;
 }
diff --git a/src/app/op-log/model/model-config.ts b/src/app/op-log/model/model-config.ts
index a98c698ddf..abd2cfafa5 100644
--- a/src/app/op-log/model/model-config.ts
+++ b/src/app/op-log/model/model-config.ts
@@ -26,6 +26,8 @@ import { initialMetricState } from '../../features/metric/store/metric.reducer';
 import { initialTaskState } from '../../features/tasks/store/task.reducer';
 import { initialTagState } from '../../features/tag/store/tag.reducer';
 import { initialSimpleCounterState } from '../../features/simple-counter/store/simple-counter.reducer';
+import { initialSectionState } from '../../features/section/store/section.reducer';
+import { SectionState } from '../../features/section/section.model';
 import { initialTaskRepeatCfgState } from '../../features/task-repeat-cfg/store/task-repeat-cfg.reducer';
 import {
   ArchiveModel,
@@ -55,6 +57,7 @@ export type AllModelConfig = {
   task: ModelCfg<TaskState>;
   tag: ModelCfg<TagState>;
   simpleCounter: ModelCfg<SimpleCounterState>;
+  section: ModelCfg<SectionState>;
   taskRepeatCfg: ModelCfg<TaskRepeatCfgState>;
   reminders: ModelCfg<Reminder[]>;
   timeTracking: ModelCfg<TimeTrackingState>;
@@ -91,6 +94,11 @@ export const MODEL_CONFIGS: AllModelConfig = {
     isMainFileModel: true,
     repair: fixEntityStateConsistency,
   },
+  section: {
+    defaultData: initialSectionState,
+    isMainFileModel: true,
+    repair: fixEntityStateConsistency,
+  },
   note: {
     defaultData: initialNoteState,
     isMainFileModel: true,
diff --git a/src/app/op-log/persistence/extract-entity-keys.ts b/src/app/op-log/persistence/extract-entity-keys.ts
index 5e0c120c86..006679a771 100644
--- a/src/app/op-log/persistence/extract-entity-keys.ts
+++ b/src/app/op-log/persistence/extract-entity-keys.ts
@@ -25,6 +25,7 @@ export const extractEntityKeysFromState = (state: AppStateSnapshot): string[] =>
     { key: 'SIMPLE_COUNTER', state: state.simpleCounter as EntityState },
     { key: 'TASK_REPEAT_CFG', state: state.taskRepeatCfg as EntityState },
     { key: 'METRIC', state: state.metric as EntityState },
+    { key: 'SECTION', state: state.section as EntityState },
   ];
 
   for (const { key, state: entityState } of entityStates) {
diff --git a/src/app/op-log/persistence/operation-log-compaction.service.spec.ts b/src/app/op-log/persistence/operation-log-compaction.service.spec.ts
index 7b5b2ef526..0d0fd65e61 100644
--- a/src/app/op-log/persistence/operation-log-compaction.service.spec.ts
+++ b/src/app/op-log/persistence/operation-log-compaction.service.spec.ts
@@ -718,6 +718,7 @@ describe('OperationLogCompactionService', () => {
         archiveOld: 'TASK', // Archives map to TASK
         pluginUserData: 'PLUGIN_USER_DATA',
         pluginMetadata: 'PLUGIN_METADATA',
+        section: 'SECTION',
       };
 
       const missingModels: string[] = [];
diff --git a/src/app/op-log/validation/data-repair.ts b/src/app/op-log/validation/data-repair.ts
index 45474ce91e..67cd99c2b9 100644
--- a/src/app/op-log/validation/data-repair.ts
+++ b/src/app/op-log/validation/data-repair.ts
@@ -39,6 +39,7 @@ const ENTITY_STATE_KEYS: (keyof AppDataCompleteLegacy)[] = [
   'metric',
   'task',
   'taskRepeatCfg',
+  'section',
 ];
 
 export const dataRepair = (
@@ -93,6 +94,14 @@ export const dataRepair = (
     dataOut.reminders = [];
   }
 
+  // Initialize section slice if missing — legacy pf databases (pre-section
+  // feature) don't carry one, and Typia's `DataToValidate` validator
+  // requires it. Without this, `validateFull` after `dataRepair` still
+  // fails and OperationLogMigrationService aborts the migration.
+  if (!dataOut.section) {
+    dataOut.section = { ids: [], entities: {} };
+  }
+
   // NOTE: We no longer merge archiveOld into archiveYoung during repair.
   // The dual-archive architecture keeps them separate for proper age-based archiving.
 
@@ -122,6 +131,7 @@ export const dataRepair = (
   dataOut = _removeNonExistentTagsFromTasks(dataOut, summary);
   dataOut = _addInboxProjectIdIfNecessary(dataOut, summary);
   dataOut = _repairMenuTree(dataOut, summary);
+  dataOut = _repairSections(dataOut, summary);
   dataOut = autoFixTypiaErrors(dataOut, errors);
   summary.typeErrorsFixed = errors.length;
 
@@ -1356,3 +1366,66 @@ const _repairMenuTree = (
 
   return data;
 };
+
+const _repairSections = (
+  data: AppDataComplete,
+  summary: RepairSummary,
+): AppDataComplete => {
+  const sectionState = data.section;
+  if (!sectionState?.ids?.length) return data;
+
+  const validProjectIds = new Set<string>(data.project.ids as string[]);
+  const validTaskIds = new Set<string>(data.task.ids as string[]);
+
+  const keptIds: string[] = [];
+  const newEntities: typeof sectionState.entities = {};
+  let droppedSections = 0;
+  let droppedTaskRefs = 0;
+
+  for (const sid of sectionState.ids as string[]) {
+    const section = sectionState.entities[sid];
+    if (!section) continue;
+
+    // Sections are only valid in PROJECT contexts (with a live projectId)
+    // or the singleton TODAY tag. Custom-tag sections are rejected at
+    // dispatch boundaries; surviving ones in stored data are dropped.
+    const isValidProject =
+      section.contextType === 'PROJECT' && validProjectIds.has(section.contextId);
+    const isTodayTag =
+      section.contextType === 'TAG' && section.contextId === TODAY_TAG.id;
+    if (!isValidProject && !isTodayTag) {
+      droppedSections++;
+      continue;
+    }
+
+    // Defend against malformed remote payloads where `taskIds` is not
+    // an array (truthy `?? []` would slip through and `.filter` would
+    // throw or yield garbage on a string / object value).
+    const taskIds = Array.isArray(section.taskIds) ? section.taskIds : [];
+    const filtered = taskIds.filter((tid) => validTaskIds.has(tid));
+    if (filtered.length !== taskIds.length) {
+      droppedTaskRefs += taskIds.length - filtered.length;
+      newEntities[sid] = { ...section, taskIds: filtered };
+    } else {
+      newEntities[sid] = section;
+    }
+    keptIds.push(sid);
+  }
+
+  if (droppedSections === 0 && droppedTaskRefs === 0) return data;
+
+  data.section = { ids: keptIds, entities: newEntities };
+  if (droppedSections > 0) {
+    OpLog.warn(
+      `[data-repair] Removed ${droppedSections} section(s) with missing project/tag`,
+    );
+    summary.invalidReferencesRemoved += droppedSections;
+  }
+  if (droppedTaskRefs > 0) {
+    OpLog.warn(
+      `[data-repair] Removed ${droppedTaskRefs} stale task reference(s) from sections`,
+    );
+    summary.invalidReferencesRemoved += droppedTaskRefs;
+  }
+  return data;
+};
diff --git a/src/app/op-log/validation/is-related-model-data-valid.ts b/src/app/op-log/validation/is-related-model-data-valid.ts
index 2f578ea6ff..c06511ea0d 100644
--- a/src/app/op-log/validation/is-related-model-data-valid.ts
+++ b/src/app/op-log/validation/is-related-model-data-valid.ts
@@ -85,6 +85,9 @@ export const isRelatedModelDataValid = (d: AppDataComplete): boolean => {
     return false;
   }
 
+  // Section orphans (missing context, stale taskIds) are repaired by
+  // `repairSections` in data-repair.ts; no separate validation step.
+
   return true;
 };
 
diff --git a/src/app/op-log/validation/state-validity-test-utils.ts b/src/app/op-log/validation/state-validity-test-utils.ts
index 94cab56b68..faa5645aa5 100644
--- a/src/app/op-log/validation/state-validity-test-utils.ts
+++ b/src/app/op-log/validation/state-validity-test-utils.ts
@@ -41,6 +41,7 @@ import { plannerFeatureKey } from '../../features/planner/store/planner.reducer'
 import { TIME_TRACKING_FEATURE_KEY } from '../../features/time-tracking/store/time-tracking.reducer';
 import { appStateFeatureKey } from '../../root-store/app-state/app-state.reducer';
 import { getDbDateStr } from '../../util/get-db-date-str';
+import { initialSectionState } from '../../features/section/store/section.reducer';
 
 /**
  * Creates a minimal valid AppDataComplete state.
@@ -87,6 +88,7 @@ export const createValidAppData = (
       entities: {},
       todayOrder: [],
     },
+    section: initialSectionState,
     menuTree: {
       ...menuTreeInitialState,
       projectTree: [{ k: MenuTreeKind.PROJECT, id: 'INBOX' } as MenuTreeProjectNode],
@@ -332,6 +334,7 @@ export const rootStateToAppData = (
     reminders?: AppDataComplete['reminders'];
     pluginUserData?: AppDataComplete['pluginUserData'];
     pluginMetadata?: AppDataComplete['pluginMetadata'];
+    section?: AppDataComplete['section'];
   } = {},
 ): AppDataComplete => {
   return {
@@ -344,6 +347,7 @@ export const rootStateToAppData = (
     planner: state[plannerFeatureKey],
     boards: state[BOARDS_FEATURE_NAME],
     timeTracking: state[TIME_TRACKING_FEATURE_KEY],
+    section: additionalData.section || initialSectionState,
     // These are either from additional data or defaults
     simpleCounter: additionalData.simpleCounter || initialSimpleCounterState,
     taskRepeatCfg: additionalData.taskRepeatCfg || initialTaskRepeatCfgState,
diff --git a/src/app/op-log/validation/validate-state.service.spec.ts b/src/app/op-log/validation/validate-state.service.spec.ts
index c67e017e5f..8671899862 100644
--- a/src/app/op-log/validation/validate-state.service.spec.ts
+++ b/src/app/op-log/validation/validate-state.service.spec.ts
@@ -31,6 +31,7 @@ describe('ValidateStateService', () => {
     project: { ids: [], entities: {} },
     tag: { ids: [], entities: {} },
     note: { ids: [], entities: {}, todayOrder: [] },
+    section: { ids: [], entities: {} },
     simpleCounter: { ids: [], entities: {} },
     issueProvider: { ids: [], entities: {} },
     taskRepeatCfg: { ids: [], entities: {} },
diff --git a/src/app/op-log/validation/validation-fn.ts b/src/app/op-log/validation/validation-fn.ts
index b93745b8ae..ad3fc1f85e 100644
--- a/src/app/op-log/validation/validation-fn.ts
+++ b/src/app/op-log/validation/validation-fn.ts
@@ -8,6 +8,7 @@ import {
   TimeTrackingState,
 } from '../../features/time-tracking/time-tracking.model';
 import { ProjectState } from '../../features/project/project.model';
+import { SectionState } from '../../features/section/section.model';
 import { MenuTreeState } from '../../features/menu-tree/store/menu-tree.model';
 import { TaskState } from '../../features/tasks/task.model';
 import { createValidate } from 'typia';
@@ -52,6 +53,7 @@ const _validateGlobalConfig = createValidate<GlobalConfigState>();
 const _validateTimeTracking = createValidate<TimeTrackingState>();
 const _validatePluginUserData = createValidate<PluginUserDataState>();
 const _validatePluginMetadata = createValidate<PluginMetaDataState>();
+const _validateSection = createValidate<SectionState>();
 
 export const validateAllData = <R>(
   d: AppDataComplete | R,
@@ -101,6 +103,7 @@ export const appDataValidators: {
     _wrapValidate(_validatePluginUserData(d)),
   pluginMetadata: <R>(d: R | PluginMetaDataState) =>
     _wrapValidate(_validatePluginMetadata(d)),
+  section: <R>(d: R | SectionState) => _wrapValidate(_validateSection(d), d, true),
 } as const;
 
 const validateArchiveModel = <R>(d: ArchiveModel | R): ValidationResult<ArchiveModel> => {
diff --git a/src/app/root-store/feature-stores.module.ts b/src/app/root-store/feature-stores.module.ts
index e067bcfd63..8e3f14b06b 100644
--- a/src/app/root-store/feature-stores.module.ts
+++ b/src/app/root-store/feature-stores.module.ts
@@ -40,6 +40,10 @@ import {
   simpleCounterReducer,
 } from '../features/simple-counter/store/simple-counter.reducer';
 import { SimpleCounterEffects } from '../features/simple-counter/store/simple-counter.effects';
+import {
+  SECTION_FEATURE_NAME,
+  sectionReducer,
+} from '../features/section/store/section.reducer';
 import { TAG_FEATURE_NAME, tagReducer } from '../features/tag/store/tag.reducer';
 import { TagEffects } from '../features/tag/store/tag.effects';
 import {
@@ -137,6 +141,8 @@ import {
     StoreModule.forFeature(SIMPLE_COUNTER_FEATURE_NAME, simpleCounterReducer),
     EffectsModule.forFeature([SimpleCounterEffects]),
 
+    StoreModule.forFeature(SECTION_FEATURE_NAME, sectionReducer),
+
     StoreModule.forFeature(TAG_FEATURE_NAME, tagReducer),
     EffectsModule.forFeature([TagEffects]),
 
diff --git a/src/app/root-store/meta/meta-reducer-registry.ts b/src/app/root-store/meta/meta-reducer-registry.ts
index b30ca1a6c3..0794fc4fde 100644
--- a/src/app/root-store/meta/meta-reducer-registry.ts
+++ b/src/app/root-store/meta/meta-reducer-registry.ts
@@ -10,6 +10,7 @@ import { taskSharedSchedulingMetaReducer } from './task-shared-meta-reducers/tas
 import { taskSharedDeadlineMetaReducer } from './task-shared-meta-reducers/task-shared-deadline.reducer';
 import { projectSharedMetaReducer } from './task-shared-meta-reducers/project-shared.reducer';
 import { tagSharedMetaReducer } from './task-shared-meta-reducers/tag-shared.reducer';
+import { sectionSharedMetaReducer } from './task-shared-meta-reducers/section-shared.reducer';
 import { issueProviderSharedMetaReducer } from './task-shared-meta-reducers/issue-provider-shared.reducer';
 import { taskRepeatCfgSharedMetaReducer } from './task-shared-meta-reducers/task-repeat-cfg-shared.reducer';
 import { plannerSharedMetaReducer } from './task-shared-meta-reducers/planner-shared.reducer';
@@ -37,6 +38,14 @@ import { actionLoggerReducer } from './action-logger.reducer';
  * Captures task context before deletion for undo functionality.
  * Must run before CRUD operations that actually delete.
  *
+ * ## Phase 3.5: Pre-CRUD Entity-Cascade Snapshots
+ * Meta-reducers that must read task/project/tag state BEFORE Phase 4
+ * mutates it (e.g. resolving a task's old projectId on
+ * moveToOtherProject, or its old tagIds on updateTask). Once Phase 4
+ * applies, those values are gone.
+ * - sectionShared: section.taskIds cleanup on task move/delete + tag
+ *   removal; orphan-section removal on project/tag delete.
+ *
  * ## Phase 4: Core CRUD Operations
  * Task add/update/delete with project & tag cleanup.
  * These run in dependency order:
@@ -88,6 +97,12 @@ export const META_REDUCERS: MetaReducer[] = [
   // Captures task context before deletion for undo/restore.
   undoTaskDeleteMetaReducer,
 
+  // sectionSharedMetaReducer must run BEFORE taskSharedCrudMetaReducer because
+  // it needs to expand subTaskIds via state.task.entities for the deleteTasks
+  // bulk action — once Phase 4 strips the parent, the subtask references are
+  // gone and section.taskIds entries pointing at removed subtasks would leak.
+  sectionSharedMetaReducer, // Task deletion → prune section.taskIds (incl. subtasks)
+
   // ═══════════════════════════════════════════════════════════════════════════
   // PHASE 4: CORE CRUD OPERATIONS (Ordered by dependency)
   // ═══════════════════════════════════════════════════════════════════════════
@@ -129,7 +144,9 @@ export const META_REDUCERS: MetaReducer[] = [
  * Critical constraints:
  * 1. operationCaptureMetaReducer MUST be at index 0 (captures state BEFORE any modifications)
  * 2. bulkOperationsMetaReducer MUST be at index 1 (unwraps bulk dispatches early)
- * 3. actionLoggerReducer MUST be last (pure logging after all modifications)
+ * 3. sectionSharedMetaReducer (Phase 3.5) MUST run before taskSharedCrudMetaReducer
+ *    (it reads pre-CRUD task state for moveToOtherProject and updateTask handlers)
+ * 4. actionLoggerReducer MUST be last (pure logging after all modifications)
  */
 const validateMetaReducerOrdering = (): void => {
   if (!isDevMode()) {
@@ -152,6 +169,17 @@ const validateMetaReducerOrdering = (): void => {
     );
   }
 
+  // Phase 3.5: sectionSharedMetaReducer must precede taskSharedCrudMetaReducer.
+  // It needs to read state.task.entities for moveToOtherProject (oldProjectId)
+  // and updateTask (oldTagIds) — values that Phase 4 mutates away.
+  const sectionIdx = META_REDUCERS.indexOf(sectionSharedMetaReducer);
+  const crudIdx = META_REDUCERS.indexOf(taskSharedCrudMetaReducer);
+  if (sectionIdx === -1 || crudIdx === -1 || sectionIdx >= crudIdx) {
+    errors.push(
+      'sectionSharedMetaReducer MUST run before taskSharedCrudMetaReducer (Phase 3.5 — pre-CRUD state read)',
+    );
+  }
+
   // Check actionLoggerReducer is last
   if (META_REDUCERS[META_REDUCERS.length - 1] !== actionLoggerReducer) {
     errors.push(
diff --git a/src/app/root-store/meta/task-shared-meta-reducers/index.ts b/src/app/root-store/meta/task-shared-meta-reducers/index.ts
index 6b3e48ee2b..3ee4772278 100644
--- a/src/app/root-store/meta/task-shared-meta-reducers/index.ts
+++ b/src/app/root-store/meta/task-shared-meta-reducers/index.ts
@@ -4,6 +4,7 @@ export { taskSharedSchedulingMetaReducer } from './task-shared-scheduling.reduce
 export { taskSharedDeadlineMetaReducer } from './task-shared-deadline.reducer';
 export { projectSharedMetaReducer } from './project-shared.reducer';
 export { tagSharedMetaReducer } from './tag-shared.reducer';
+export { sectionSharedMetaReducer } from './section-shared.reducer';
 export { plannerSharedMetaReducer } from './planner-shared.reducer';
 export { taskBatchUpdateMetaReducer } from './task-batch-update.reducer';
 export { issueProviderSharedMetaReducer } from './issue-provider-shared.reducer';
diff --git a/src/app/root-store/meta/task-shared-meta-reducers/section-shared.reducer.spec.ts b/src/app/root-store/meta/task-shared-meta-reducers/section-shared.reducer.spec.ts
new file mode 100644
index 0000000000..775be86a9c
--- /dev/null
+++ b/src/app/root-store/meta/task-shared-meta-reducers/section-shared.reducer.spec.ts
@@ -0,0 +1,474 @@
+import { Action, ActionReducer } from '@ngrx/store';
+import { sectionSharedMetaReducer } from './section-shared.reducer';
+import { TaskSharedActions } from '../task-shared.actions';
+import { RootState } from '../../root-state';
+import { TASK_FEATURE_NAME } from '../../../features/tasks/store/task.reducer';
+import { TAG_FEATURE_NAME } from '../../../features/tag/store/tag.reducer';
+import { SECTION_FEATURE_NAME } from '../../../features/section/store/section.reducer';
+import { Section, SectionState } from '../../../features/section/section.model';
+import { createBaseState, createMockTask } from './test-utils';
+import { Task } from '../../../features/tasks/task.model';
+import { WorkContextType } from '../../../features/work-context/work-context.model';
+import { TODAY_TAG } from '../../../features/tag/tag.const';
+
+const sectionStateOf = (sections: Section[]): SectionState => ({
+  ids: sections.map((s) => s.id),
+  entities: Object.fromEntries(sections.map((s) => [s.id, s])),
+});
+
+const stateWith = (
+  tasks: Record<string, Partial<Task>>,
+  sections: Section[],
+): RootState & { [SECTION_FEATURE_NAME]: SectionState } => {
+  const base = createBaseState();
+  const taskIds = Object.keys(tasks);
+  const taskEntities: Record<string, Task> = {};
+  for (const id of taskIds) {
+    taskEntities[id] = createMockTask({ id, ...tasks[id] });
+  }
+  return {
+    ...base,
+    [TASK_FEATURE_NAME]: {
+      ...base[TASK_FEATURE_NAME],
+      ids: taskIds,
+      entities: taskEntities,
+    },
+    [SECTION_FEATURE_NAME]: sectionStateOf(sections),
+  };
+};
+
+describe('sectionSharedMetaReducer', () => {
+  let mockReducer: jasmine.Spy;
+  let metaReducer: ActionReducer<any, Action>;
+
+  beforeEach(() => {
+    mockReducer = jasmine.createSpy('reducer').and.callFake((s) => s);
+    metaReducer = sectionSharedMetaReducer(mockReducer);
+  });
+
+  it('removes a deleted task id from any section that referenced it', () => {
+    const state = stateWith({ t1: {}, t2: {} }, [
+      {
+        id: 's1',
+        contextId: 'p1',
+        contextType: WorkContextType.PROJECT,
+        title: 'A',
+        taskIds: ['t1', 't2'],
+      },
+    ]);
+    const action = TaskSharedActions.deleteTask({
+      task: state[TASK_FEATURE_NAME].entities.t1 as Task,
+    } as any);
+
+    metaReducer(state, action);
+
+    const updated = (mockReducer.calls.mostRecent().args[0] as any)[
+      SECTION_FEATURE_NAME
+    ] as SectionState;
+    expect(updated.entities['s1']?.taskIds).toEqual(['t2']);
+  });
+
+  it('cascades subtask removal alongside the parent', () => {
+    const state = stateWith(
+      {
+        parent: { subTaskIds: ['sub1', 'sub2'] },
+        sub1: { parentId: 'parent' },
+        sub2: { parentId: 'parent' },
+        other: {},
+      },
+      [
+        {
+          id: 's1',
+          contextId: 'p1',
+          contextType: WorkContextType.PROJECT,
+          title: 'A',
+          // sections only hold parent task ids in the new model, but the
+          // meta-reducer must defensively scrub subtask ids too.
+          taskIds: ['parent', 'other'],
+        },
+        {
+          id: 's2',
+          contextId: 'p1',
+          contextType: WorkContextType.PROJECT,
+          title: 'B',
+          taskIds: ['sub1'],
+        },
+      ],
+    );
+
+    metaReducer(
+      state,
+      TaskSharedActions.deleteTask({
+        task: state[TASK_FEATURE_NAME].entities.parent as Task,
+      } as any),
+    );
+
+    const updated = (mockReducer.calls.mostRecent().args[0] as any)[
+      SECTION_FEATURE_NAME
+    ] as SectionState;
+    expect(updated.entities['s1']?.taskIds).toEqual(['other']);
+    expect(updated.entities['s2']?.taskIds).toEqual([]);
+  });
+
+  it('strips archived tasks (and their subtasks) from sections on moveToArchive', () => {
+    const state = stateWith(
+      {
+        parent: { subTaskIds: ['sub1'] },
+        sub1: { parentId: 'parent' },
+        other: {},
+      },
+      [
+        {
+          id: 's1',
+          contextId: 'p1',
+          contextType: WorkContextType.PROJECT,
+          title: 'A',
+          taskIds: ['parent', 'other'],
+        },
+        {
+          id: 's2',
+          contextId: 'p1',
+          contextType: WorkContextType.PROJECT,
+          title: 'B',
+          taskIds: ['sub1'],
+        },
+      ],
+    );
+
+    metaReducer(
+      state,
+      TaskSharedActions.moveToArchive({
+        tasks: [{ ...state[TASK_FEATURE_NAME].entities.parent, subTasks: [] } as any],
+      } as any),
+    );
+
+    const updated = (mockReducer.calls.mostRecent().args[0] as any)[
+      SECTION_FEATURE_NAME
+    ] as SectionState;
+    expect(updated.entities['s1']?.taskIds).toEqual(['other']);
+    expect(updated.entities['s2']?.taskIds).toEqual([]);
+  });
+
+  it('handles deleteTasks (bulk) across multiple sections', () => {
+    const state = stateWith({ t1: {}, t2: {}, t3: {}, t4: {} }, [
+      {
+        id: 's1',
+        contextId: 'p1',
+        contextType: WorkContextType.PROJECT,
+        title: 'A',
+        taskIds: ['t1', 't2'],
+      },
+      {
+        id: 's2',
+        contextId: 'p1',
+        contextType: WorkContextType.PROJECT,
+        title: 'B',
+        taskIds: ['t3', 't4'],
+      },
+    ]);
+
+    metaReducer(state, TaskSharedActions.deleteTasks({ taskIds: ['t1', 't3'] }));
+
+    const updated = (mockReducer.calls.mostRecent().args[0] as any)[
+      SECTION_FEATURE_NAME
+    ] as SectionState;
+    expect(updated.entities['s1']?.taskIds).toEqual(['t2']);
+    expect(updated.entities['s2']?.taskIds).toEqual(['t4']);
+  });
+
+  it('passes through unrelated actions unchanged', () => {
+    const state = stateWith({ t1: {} }, [
+      {
+        id: 's1',
+        contextId: 'p1',
+        contextType: WorkContextType.PROJECT,
+        title: 'A',
+        taskIds: ['t1'],
+      },
+    ]);
+
+    metaReducer(state, { type: '[Other] noop' } as Action);
+    expect(mockReducer.calls.mostRecent().args[0]).toBe(state);
+  });
+
+  it('is a no-op when no section references the deleted task', () => {
+    const state = stateWith({ t1: {}, t2: {} }, [
+      {
+        id: 's1',
+        contextId: 'p1',
+        contextType: WorkContextType.PROJECT,
+        title: 'A',
+        taskIds: ['t2'],
+      },
+    ]);
+
+    metaReducer(
+      state,
+      TaskSharedActions.deleteTask({
+        task: state[TASK_FEATURE_NAME].entities.t1 as Task,
+      } as any),
+    );
+
+    expect(mockReducer.calls.mostRecent().args[0]).toBe(state);
+  });
+
+  describe('context deletion', () => {
+    it('removes sections owned by a deleted project but leaves other contexts alone', () => {
+      const state = stateWith({}, [
+        {
+          id: 'sP',
+          contextId: 'p1',
+          contextType: WorkContextType.PROJECT,
+          title: 'In project',
+          taskIds: [],
+        },
+        {
+          id: 'sP2',
+          contextId: 'p2',
+          contextType: WorkContextType.PROJECT,
+          title: 'Other project',
+          taskIds: [],
+        },
+        {
+          id: 'sT',
+          contextId: 'p1',
+          contextType: WorkContextType.TAG,
+          title: 'Tag with same id (no collision)',
+          taskIds: [],
+        },
+      ]);
+
+      metaReducer(
+        state,
+        TaskSharedActions.deleteProject({
+          projectId: 'p1',
+          allTaskIds: [],
+          noteIds: [],
+        } as any),
+      );
+
+      const updated = (mockReducer.calls.mostRecent().args[0] as any)[
+        SECTION_FEATURE_NAME
+      ] as SectionState;
+      expect(updated.entities['sP']).toBeUndefined();
+      expect(updated.entities['sP2']).toBeDefined();
+      // contextType='TAG' with the same id is intentionally not touched.
+      expect(updated.entities['sT']).toBeDefined();
+    });
+
+    it('on deleteProject, also strips cascaded task ids from tag-context sections', () => {
+      // task t1 lives in project p1 AND in tag tA. Deleting p1 removes t1
+      // (task.reducer cascades removeMany(allTaskIds)); the tag-context
+      // section sA must drop t1 from its taskIds in the same reducer pass.
+      const state = stateWith(
+        {
+          t1: { projectId: 'p1', tagIds: ['tA'] },
+          t2: { projectId: 'p1' },
+        },
+        [
+          {
+            id: 'sP',
+            contextId: 'p1',
+            contextType: WorkContextType.PROJECT,
+            title: 'Project section',
+            taskIds: ['t1', 't2'],
+          },
+          {
+            id: 'sA',
+            contextId: 'tA',
+            contextType: WorkContextType.TAG,
+            title: 'Tag section',
+            taskIds: ['t1'],
+          },
+        ],
+      );
+
+      metaReducer(
+        state,
+        TaskSharedActions.deleteProject({
+          projectId: 'p1',
+          allTaskIds: ['t1', 't2'],
+          noteIds: [],
+        } as any),
+      );
+
+      const updated = (mockReducer.calls.mostRecent().args[0] as any)[
+        SECTION_FEATURE_NAME
+      ] as SectionState;
+      expect(updated.entities['sP']).toBeUndefined();
+      expect(updated.entities['sA']).toBeDefined();
+      expect(updated.entities['sA']?.taskIds).toEqual([]);
+    });
+
+    it('strips a moved task (and its subtasks) from sections in the old project only', () => {
+      const state = stateWith(
+        {
+          parent: { projectId: 'oldP', subTaskIds: ['sub1'] },
+          sub1: { projectId: 'oldP', parentId: 'parent' },
+        },
+        [
+          {
+            id: 'sOld',
+            contextId: 'oldP',
+            contextType: WorkContextType.PROJECT,
+            title: 'old project section',
+            taskIds: ['parent', 'sub1', 'unrelated'],
+          },
+          {
+            id: 'sOther',
+            contextId: 'newP',
+            contextType: WorkContextType.PROJECT,
+            title: 'target project section',
+            taskIds: [],
+          },
+          {
+            id: 'sTag',
+            contextId: 'oldP',
+            contextType: WorkContextType.TAG,
+            title: 'tag with same id as old project',
+            taskIds: ['parent'],
+          },
+        ],
+      );
+
+      metaReducer(
+        state,
+        TaskSharedActions.moveToOtherProject({
+          task: state[TASK_FEATURE_NAME].entities.parent as any,
+          targetProjectId: 'newP',
+        } as any),
+      );
+
+      const updated = (mockReducer.calls.mostRecent().args[0] as any)[
+        SECTION_FEATURE_NAME
+      ] as SectionState;
+      expect(updated.entities['sOld']?.taskIds).toEqual(['unrelated']);
+      // Target project section is untouched.
+      expect(updated.entities['sOther']?.taskIds).toEqual([]);
+      // Tag-context section keeps the parent — tag membership didn't change.
+      expect(updated.entities['sTag']?.taskIds).toEqual(['parent']);
+    });
+
+    it('updateTask without tagIds change is a no-op for sections', () => {
+      const state = stateWith({ t1: { tagIds: ['a'] } }, [
+        {
+          id: 'sa',
+          contextId: 'a',
+          contextType: WorkContextType.TAG,
+          title: 'tag a',
+          taskIds: ['t1'],
+        },
+      ]);
+
+      metaReducer(
+        state,
+        TaskSharedActions.updateTask({
+          task: { id: 't1', changes: { title: 'renamed' } },
+        } as any),
+      );
+
+      expect(mockReducer.calls.mostRecent().args[0]).toBe(state);
+    });
+  });
+
+  describe('TODAY-tag removal cleanup (diff-based)', () => {
+    // The metaReducer compares pre/post TODAY_TAG.taskIds and strips any
+    // ids that left TODAY from TODAY-context sections. We simulate the
+    // tag reducer's effect by having the mock return a state where
+    // TODAY's taskIds shrank.
+    const stateWithTodayTaskIds = (
+      todayTaskIds: string[],
+      tasks: Record<string, Partial<Task>>,
+      sections: Section[],
+    ): RootState & { [SECTION_FEATURE_NAME]: SectionState } => {
+      const base = stateWith(tasks, sections);
+      return {
+        ...base,
+        [TAG_FEATURE_NAME]: {
+          ...base[TAG_FEATURE_NAME],
+          entities: {
+            ...base[TAG_FEATURE_NAME].entities,
+            [TODAY_TAG.id]: {
+              ...base[TAG_FEATURE_NAME].entities[TODAY_TAG.id],
+              taskIds: todayTaskIds,
+            },
+          },
+        },
+      } as any;
+    };
+
+    const mockTagReducerRemovesFromToday = (remainingTodayTaskIds: string[]): void => {
+      mockReducer.and.callFake((s: any) => ({
+        ...s,
+        [TAG_FEATURE_NAME]: {
+          ...s[TAG_FEATURE_NAME],
+          entities: {
+            ...s[TAG_FEATURE_NAME].entities,
+            [TODAY_TAG.id]: {
+              ...s[TAG_FEATURE_NAME].entities[TODAY_TAG.id],
+              taskIds: remainingTodayTaskIds,
+            },
+          },
+        },
+      }));
+    };
+
+    it('strips taskIds that left TODAY from TODAY-context sections, leaving non-TODAY contexts alone', () => {
+      const state = stateWithTodayTaskIds(
+        ['t1', 't2', 't3'],
+        { t1: {}, t2: {}, t3: {} },
+        [
+          {
+            id: 'today-sec',
+            contextId: TODAY_TAG.id,
+            contextType: WorkContextType.TAG,
+            title: 'Morning',
+            taskIds: ['t1', 't2', 't3'],
+          },
+          {
+            id: 'project-sec',
+            contextId: 'p1',
+            contextType: WorkContextType.PROJECT,
+            title: 'Project',
+            taskIds: ['t1', 't2'],
+          },
+        ],
+      );
+      mockTagReducerRemovesFromToday(['t2']);
+
+      const result = metaReducer(state, { type: '[Tag] simulated removal' } as Action);
+
+      const updated = (result as any)[SECTION_FEATURE_NAME] as SectionState;
+      expect(updated.entities['today-sec']?.taskIds).toEqual(['t2']);
+      // Project-context sections are intentionally not touched.
+      expect(updated.entities['project-sec']?.taskIds).toEqual(['t1', 't2']);
+    });
+
+    it('cascades subtasks of a removed parent on TODAY removal', () => {
+      const state = stateWithTodayTaskIds(
+        ['parent', 'other'],
+        {
+          parent: { subTaskIds: ['sub1', 'sub2'] },
+          sub1: { parentId: 'parent' },
+          sub2: { parentId: 'parent' },
+          other: {},
+        },
+        [
+          {
+            id: 'today-sec',
+            contextId: TODAY_TAG.id,
+            contextType: WorkContextType.TAG,
+            title: 'Morning',
+            taskIds: ['parent', 'sub1', 'other'],
+          },
+        ],
+      );
+      mockTagReducerRemovesFromToday(['other']);
+
+      const result = metaReducer(state, { type: '[Tag] simulated removal' } as Action);
+
+      const updated = (result as any)[SECTION_FEATURE_NAME] as SectionState;
+      expect(updated.entities['today-sec']?.taskIds).toEqual(['other']);
+    });
+  });
+});
diff --git a/src/app/root-store/meta/task-shared-meta-reducers/section-shared.reducer.ts b/src/app/root-store/meta/task-shared-meta-reducers/section-shared.reducer.ts
new file mode 100644
index 0000000000..56c4ae5517
--- /dev/null
+++ b/src/app/root-store/meta/task-shared-meta-reducers/section-shared.reducer.ts
@@ -0,0 +1,345 @@
+import { Action, ActionReducer, MetaReducer } from '@ngrx/store';
+import { Update } from '@ngrx/entity';
+import { RootState } from '../../root-state';
+import {
+  adapter as sectionAdapter,
+  SECTION_FEATURE_NAME,
+} from '../../../features/section/store/section.reducer';
+import { Section, SectionState } from '../../../features/section/section.model';
+import { TaskSharedActions } from '../task-shared.actions';
+import { TASK_FEATURE_NAME } from '../../../features/tasks/store/task.reducer';
+import { TAG_FEATURE_NAME } from '../../../features/tag/store/tag.reducer';
+import { Task } from '../../../features/tasks/task.model';
+import { WorkContextType } from '../../../features/work-context/work-context.model';
+import { TODAY_TAG } from '../../../features/tag/tag.const';
+
+// Must run before taskSharedCrudMetaReducer — handlers read pre-update
+// task state to compute cleanups. Position pinned by
+// `validateMetaReducerOrdering()` in meta-reducer-registry.ts.
+interface ExtendedState extends RootState {
+  [SECTION_FEATURE_NAME]: SectionState;
+}
+
+type Handler = (state: ExtendedState, action: Action) => ExtendedState;
+
+const collectAffectedTaskIds = (
+  state: ExtendedState,
+  primaryTaskIds: string[],
+): string[] => {
+  const taskState = state[TASK_FEATURE_NAME];
+  const all = new Set<string>(primaryTaskIds);
+  for (const id of primaryTaskIds) {
+    const t = taskState.entities[id];
+    if (t?.subTaskIds?.length) {
+      for (const sub of t.subTaskIds) all.add(sub);
+    }
+  }
+  return Array.from(all);
+};
+
+/**
+ * Walk `taskIds` once removing entries in `removedSet`. Returns `null`
+ * when nothing was removed so callers can keep the original array
+ * reference, avoiding the `.some` + `.filter` double-walk.
+ */
+const filterRemovingTaskIds = (
+  taskIds: string[],
+  removedSet: Set<string>,
+): string[] | null => {
+  let next: string[] | null = null;
+  for (let i = 0; i < taskIds.length; i++) {
+    const id = taskIds[i];
+    if (removedSet.has(id)) {
+      if (next === null) next = taskIds.slice(0, i);
+    } else if (next !== null) {
+      next.push(id);
+    }
+  }
+  return next;
+};
+
+const cleanupSectionTaskIds = (
+  sectionState: SectionState,
+  removedTaskIds: string[],
+): SectionState => {
+  if (removedTaskIds.length === 0) return sectionState;
+
+  const removedSet = new Set(removedTaskIds);
+  const updates: Update<Section>[] = [];
+
+  // Iterate `state.ids` directly — `Object.values(entities)` allocates
+  // a fresh array on every dispatch, which adds up under op-log replay.
+  for (const id of sectionState.ids) {
+    const s = sectionState.entities[id];
+    if (!s) continue;
+    const filtered = filterRemovingTaskIds(s.taskIds, removedSet);
+    if (filtered !== null) {
+      updates.push({ id: s.id, changes: { taskIds: filtered } });
+    }
+  }
+
+  if (!updates.length) return sectionState;
+  return sectionAdapter.updateMany(updates, sectionState);
+};
+
+/**
+ * Drop project-scoped sections owned by the deleted project, and strip
+ * `taskIds` from TODAY-tag sections whose tasks are leaving the project.
+ */
+const removeProjectSections = (
+  sectionState: SectionState,
+  projectId: string,
+): SectionState => {
+  const idsToRemove: string[] = [];
+  for (const id of sectionState.ids) {
+    const s = sectionState.entities[id];
+    if (!s) continue;
+    if (s.contextType === WorkContextType.PROJECT && s.contextId === projectId) {
+      idsToRemove.push(s.id);
+    }
+  }
+  if (!idsToRemove.length) return sectionState;
+  return sectionAdapter.removeMany(idsToRemove, sectionState);
+};
+
+/**
+ * Strip `taskIds` from sections owned by `projectId` (PROJECT context).
+ * Used when a task leaves a project (moveToOtherProject) — its section
+ * membership in the old project becomes stale.
+ */
+const removeTaskIdsFromProjectSections = (
+  sectionState: SectionState,
+  taskIds: string[],
+  projectId: string,
+): SectionState => {
+  if (taskIds.length === 0) return sectionState;
+
+  const taskIdSet = new Set(taskIds);
+  const updates: Update<Section>[] = [];
+
+  for (const id of sectionState.ids) {
+    const s = sectionState.entities[id];
+    if (!s) continue;
+    if (s.contextType !== WorkContextType.PROJECT) continue;
+    if (s.contextId !== projectId) continue;
+    const filtered = filterRemovingTaskIds(s.taskIds, taskIdSet);
+    if (filtered !== null) {
+      updates.push({ id: s.id, changes: { taskIds: filtered } });
+    }
+  }
+
+  if (!updates.length) return sectionState;
+  return sectionAdapter.updateMany(updates, sectionState);
+};
+
+/**
+ * Strip `taskIds` from the singleton TODAY-tag section bucket.
+ */
+const removeTaskIdsFromTodaySections = (
+  sectionState: SectionState,
+  taskIds: string[],
+): SectionState => {
+  if (taskIds.length === 0) return sectionState;
+
+  const taskIdSet = new Set(taskIds);
+  const updates: Update<Section>[] = [];
+
+  for (const id of sectionState.ids) {
+    const s = sectionState.entities[id];
+    if (!s) continue;
+    if (s.contextType !== WorkContextType.TAG) continue;
+    if (s.contextId !== TODAY_TAG.id) continue;
+    const filtered = filterRemovingTaskIds(s.taskIds, taskIdSet);
+    if (filtered !== null) {
+      updates.push({ id: s.id, changes: { taskIds: filtered } });
+    }
+  }
+
+  if (!updates.length) return sectionState;
+  return sectionAdapter.updateMany(updates, sectionState);
+};
+
+const withSectionStateUpdate = (
+  state: ExtendedState,
+  next: SectionState,
+): ExtendedState =>
+  next === state[SECTION_FEATURE_NAME]
+    ? state
+    : ({ ...state, [SECTION_FEATURE_NAME]: next } as ExtendedState);
+
+const handleTaskRemoval = (
+  state: ExtendedState,
+  primaryTaskIds: string[],
+): ExtendedState => {
+  const affectedIds = collectAffectedTaskIds(state, primaryTaskIds);
+  return withSectionStateUpdate(
+    state,
+    cleanupSectionTaskIds(state[SECTION_FEATURE_NAME], affectedIds),
+  );
+};
+
+/**
+ * Task is moving from its current project to `targetProjectId`. Strip
+ * the task (and its subtasks) from the old project's sections.
+ */
+const handleMoveToOtherProject = (
+  state: ExtendedState,
+  taskId: string,
+  targetProjectId: string,
+): ExtendedState => {
+  const t = state[TASK_FEATURE_NAME].entities[taskId] as Task | undefined;
+  const oldProjectId = t?.projectId;
+  if (!oldProjectId || oldProjectId === targetProjectId) return state;
+
+  const affectedTaskIds = collectAffectedTaskIds(state, [taskId]);
+  return withSectionStateUpdate(
+    state,
+    removeTaskIdsFromProjectSections(
+      state[SECTION_FEATURE_NAME],
+      affectedTaskIds,
+      oldProjectId,
+    ),
+  );
+};
+
+/**
+ * Diff-based TODAY_TAG.taskIds cleanup. TODAY is virtual — `task.tagIds`
+ * never contains `'TODAY'`, so the set of reducers that mutate
+ * `TODAY_TAG.taskIds` is too broad to enumerate by action type
+ * (scheduleTaskWithTime, planTaskForDay, unscheduleTask, short-syntax
+ * day moves, undo paths, lww conflict resolution, …).
+ *
+ * Compares pre/post `TODAY_TAG.taskIds` after the inner reducer ran;
+ * any id that left TODAY is stripped from TODAY-tag sections.
+ *
+ * Cheap path: short-circuits on tag-state reference equality, then on
+ * TODAY entity reference equality, then on taskIds reference equality.
+ * Only when all three changed do we walk the arrays.
+ */
+const diffRemovedTodayTaskIds = (prev: RootState, next: RootState): string[] | null => {
+  const prevTagState = prev[TAG_FEATURE_NAME];
+  const nextTagState = next[TAG_FEATURE_NAME];
+  if (prevTagState === nextTagState) return null;
+  const prevToday = prevTagState.entities[TODAY_TAG.id];
+  const nextToday = nextTagState.entities[TODAY_TAG.id];
+  if (prevToday === nextToday) return null;
+  const prevIds = prevToday?.taskIds;
+  const nextIds = nextToday?.taskIds;
+  if (prevIds === nextIds || !prevIds?.length) return null;
+  const nextSet = nextIds ? new Set(nextIds) : new Set<string>();
+  const removed: string[] = [];
+  for (const id of prevIds) {
+    if (!nextSet.has(id)) removed.push(id);
+  }
+  return removed.length ? removed : null;
+};
+
+const applyTodayTagSectionCleanup = (
+  state: RootState,
+  removedTaskIds: string[],
+): RootState => {
+  const extState = state as ExtendedState;
+  const sectionState = extState[SECTION_FEATURE_NAME];
+  const cleaned = removeTaskIdsFromTodaySections(sectionState, removedTaskIds);
+  if (cleaned === sectionState) return state;
+  return { ...extState, [SECTION_FEATURE_NAME]: cleaned } as RootState;
+};
+
+/**
+ * Action-specific handlers.
+ *
+ * KNOWN FOLLOW-UPs:
+ *
+ * - `batchUpdateForProject` (plugin API) can update tagIds and delete
+ *   tasks within its single-action transform. Sections it would
+ *   otherwise affect aren't pruned. Handling it here requires walking
+ *   the operations array, which is non-trivial.
+ *
+ * - LWW conflict-resolution can reassign a task's projectId; project-
+ *   context section.taskIds can leak phantom references until the next
+ *   `dataRepair` pass clears them. Visible impact bounded by render-time
+ *   intersection in `undoneTasksBySection`.
+ */
+const ACTION_HANDLERS: Record<string, Handler> = {
+  [TaskSharedActions.deleteTask.type]: (state, action) => {
+    const { task } = action as ReturnType<typeof TaskSharedActions.deleteTask>;
+    return handleTaskRemoval(state, [task.id]);
+  },
+  [TaskSharedActions.deleteTasks.type]: (state, action) => {
+    const { taskIds } = action as ReturnType<typeof TaskSharedActions.deleteTasks>;
+    return handleTaskRemoval(state, taskIds);
+  },
+  [TaskSharedActions.moveToArchive.type]: (state, action) => {
+    // Strip archived task ids from sections. Restore is intentionally
+    // NOT a counterpart — the task comes back without a section, mirror
+    // of how restore drops missing tagIds.
+    //
+    // Union payload-subTasks with state-derived subtasks: payload covers
+    // the replay-with-missing-state case; state covers callers who pass
+    // an empty `subTasks` array.
+    const { tasks } = action as ReturnType<typeof TaskSharedActions.moveToArchive>;
+    const idSet = new Set<string>();
+    for (const t of tasks) {
+      idSet.add(t.id);
+      if (t.subTasks?.length) for (const st of t.subTasks) idSet.add(st.id);
+    }
+    const stateExpanded = collectAffectedTaskIds(
+      state,
+      tasks.map((t) => t.id),
+    );
+    for (const id of stateExpanded) idSet.add(id);
+    return withSectionStateUpdate(
+      state,
+      cleanupSectionTaskIds(state[SECTION_FEATURE_NAME], Array.from(idSet)),
+    );
+  },
+  [TaskSharedActions.deleteProject.type]: (state, action) => {
+    const { projectId, allTaskIds } = action as ReturnType<
+      typeof TaskSharedActions.deleteProject
+    >;
+    // Two-step in a single reducer pass:
+    //   1. drop sections owned by the deleted project
+    //   2. strip the deleted task ids from any remaining (TODAY-tag)
+    //      sections — task.reducer cascades removeMany(allTaskIds), so
+    //      TODAY sections that held shared tasks would otherwise keep
+    //      stale ids forever.
+    const next = withSectionStateUpdate(
+      state,
+      removeProjectSections(state[SECTION_FEATURE_NAME], projectId),
+    );
+    if (!allTaskIds.length) return next;
+    return withSectionStateUpdate(
+      next,
+      cleanupSectionTaskIds(next[SECTION_FEATURE_NAME], allTaskIds),
+    );
+  },
+  [TaskSharedActions.moveToOtherProject.type]: (state, action) => {
+    const { task, targetProjectId } = action as ReturnType<
+      typeof TaskSharedActions.moveToOtherProject
+    >;
+    return handleMoveToOtherProject(state, task.id, targetProjectId);
+  },
+};
+
+export const sectionSharedMetaReducer: MetaReducer<RootState> = (
+  reducer: ActionReducer<RootState, Action>,
+) => {
+  return (state: RootState | undefined, action: Action): RootState => {
+    if (!state) return reducer(state, action);
+    // Boot/hydration guard: skip section-side cleanup until every slice
+    // it touches is hydrated.
+    const ext = state as ExtendedState;
+    if (!ext[TASK_FEATURE_NAME] || !ext[TAG_FEATURE_NAME] || !ext[SECTION_FEATURE_NAME]) {
+      return reducer(state, action);
+    }
+    const handler = ACTION_HANDLERS[action.type];
+    const preState = handler ? handler(ext, action) : state;
+    const next = reducer(preState, action);
+    // Post-reducer TODAY_TAG.taskIds diff catches every flow that
+    // removes ids from TODAY without going through a known action.
+    const removedFromToday = diffRemovedTodayTaskIds(state, next);
+    if (!removedFromToday) return next;
+    const affected = collectAffectedTaskIds(next as ExtendedState, removedFromToday);
+    return applyTodayTagSectionCleanup(next, affected);
+  };
+};
diff --git a/src/app/t.const.ts b/src/app/t.const.ts
index ff4ada537b..5edd74f105 100644
--- a/src/app/t.const.ts
+++ b/src/app/t.const.ts
@@ -26,6 +26,7 @@ const T = {
     RESTORE_FILE_BACKUP: 'CONFIRM.RESTORE_FILE_BACKUP',
     RESTORE_FILE_BACKUP_ANDROID: 'CONFIRM.RESTORE_FILE_BACKUP_ANDROID',
     RESTORE_STRAY_BACKUP: 'CONFIRM.RESTORE_STRAY_BACKUP',
+    DELETE_SECTION: 'CONFIRM.DELETE_SECTION',
   },
   DATETIME_SCHEDULE: {
     PRESS_ENTER_AGAIN: 'DATETIME_SCHEDULE.PRESS_ENTER_AGAIN',
@@ -2461,6 +2462,7 @@ const T = {
   },
   MH: {
     ADD_NEW_TASK: 'MH.ADD_NEW_TASK',
+    ADD_SECTION: 'MH.ADD_SECTION',
     ALL_PLANNED_LIST: 'MH.ALL_PLANNED_LIST',
     BOARDS: 'MH.BOARDS',
     COPY_TASK_LIST_MARKDOWN: 'MH.COPY_TASK_LIST_MARKDOWN',
@@ -2793,6 +2795,8 @@ const T = {
   WW: {
     ADD_MORE: 'WW.ADD_MORE',
     ADD_SCHEDULED_FOR_TOMORROW: 'WW.ADD_SCHEDULED_FOR_TOMORROW',
+    ADD_SECTION_TITLE: 'WW.ADD_SECTION_TITLE',
+    SECTION_OPTIONS: 'WW.SECTION_OPTIONS',
     DONE_TASKS: 'WW.DONE_TASKS',
     DONE_TASKS_IN_ARCHIVE: 'WW.DONE_TASKS_IN_ARCHIVE',
     ESTIMATE_REMAINING: 'WW.ESTIMATE_REMAINING',
@@ -2803,6 +2807,7 @@ const T = {
     NO_DONE_TASKS: 'WW.NO_DONE_TASKS',
     NO_PLANNED_TASK_ALL_DONE: 'WW.NO_PLANNED_TASK_ALL_DONE',
     NO_PLANNED_TASKS: 'WW.NO_PLANNED_TASKS',
+    NO_TASKS_IN_MAIN_LIST: 'WW.NO_TASKS_IN_MAIN_LIST',
     RECURRING_TASKS: 'WW.RECURRING_TASKS',
     RESET_BREAK_TIMER: 'WW.RESET_BREAK_TIMER',
     TIME_ESTIMATED: 'WW.TIME_ESTIMATED',
diff --git a/src/app/ui/collapsible/collapsible.component.html b/src/app/ui/collapsible/collapsible.component.html
index 44db6c0828..a9fe353019 100644
--- a/src/app/ui/collapsible/collapsible.component.html
+++ b/src/app/ui/collapsible/collapsible.component.html
@@ -16,6 +16,8 @@
 
   <div class="collapsible-title">{{ title() }}</div>
 
+  <ng-content select="[actions]"></ng-content>
+
   @if (!isIconBefore()) {
     <mat-icon class="collapsible-expand-icon">expand_more</mat-icon>
   }
diff --git a/src/app/util/app-data-mock.ts b/src/app/util/app-data-mock.ts
index f5bc75314b..08bd1fb502 100644
--- a/src/app/util/app-data-mock.ts
+++ b/src/app/util/app-data-mock.ts
@@ -23,6 +23,7 @@ export const createAppDataCompleteMock = (): AppDataComplete => ({
     isDataLoaded: false,
   },
   tag: createEmptyEntity(),
+  section: createEmptyEntity(),
   simpleCounter: {
     ...createEmptyEntity(),
     ids: [],
diff --git a/src/app/util/parse-markdown-tasks.ts b/src/app/util/parse-markdown-tasks.ts
index 80fdf69d67..358baa95eb 100644
--- a/src/app/util/parse-markdown-tasks.ts
+++ b/src/app/util/parse-markdown-tasks.ts
@@ -1,3 +1,23 @@
+// Cap clipboard size to keep the parser from blocking the main thread on
+// pathological inputs. Tracks roughly 10k task lines at ~80 chars each.
+const MAX_INPUT_LENGTH = 800_000;
+
+const splitMarkdownLines = (text: string): string[] => {
+  // CRLF (Windows clipboard, GitHub render) → LF; strip BOM.
+  const normalized = text.replace(/^/, '').replace(/\r\n?/g, '\n');
+  return normalized.split('\n').filter((line) => line.trim().length > 0);
+};
+
+const findMinIndentLevel = (parsedLines: { indentLevel: number }[]): number => {
+  // Reduce-based to avoid `Math.min(...arr)` which throws RangeError on
+  // very large arrays (V8 spread limit).
+  let min = Infinity;
+  for (const line of parsedLines) {
+    if (line.indentLevel < min) min = line.indentLevel;
+  }
+  return min === Infinity ? 0 : min;
+};
+
 export interface ParsedMarkdownTask {
   title: string;
   isCompleted: boolean;
@@ -88,7 +108,8 @@ export const convertToMarkdownNotes = (text: string): string | null => {
     return null;
   }
 
-  const lines = text.split('\n').filter((line) => line.trim().length > 0);
+  if (text.length > MAX_INPUT_LENGTH) return null;
+  const lines = splitMarkdownLines(text);
   const convertedLines: string[] = [];
 
   for (const line of lines) {
@@ -118,7 +139,8 @@ export const parseMarkdownTasksWithStructure = (
     return null;
   }
 
-  const lines = text.split('\n').filter((line) => line.trim().length > 0);
+  if (text.length > MAX_INPUT_LENGTH) return null;
+  const lines = splitMarkdownLines(text);
   const parsedLines: ParsedLine[] = [];
 
   // Parse all lines first
@@ -137,7 +159,7 @@ export const parseMarkdownTasksWithStructure = (
   }
 
   // Find the minimum indentation level to normalize
-  const minIndentLevel = Math.min(...parsedLines.map((line) => line.indentLevel));
+  const minIndentLevel = findMinIndentLevel(parsedLines);
 
   // Normalize indentation levels by subtracting the minimum
   parsedLines.forEach((line) => {
@@ -245,7 +267,8 @@ export const parseMarkdownTasks = (text: string): ParsedMarkdownTask[] | null =>
     return null;
   }
 
-  const lines = text.split('\n').filter((line) => line.trim().length > 0);
+  if (text.length > MAX_INPUT_LENGTH) return null;
+  const lines = splitMarkdownLines(text);
   const parsedLines: ParsedLine[] = [];
 
   // Parse all lines first
@@ -264,7 +287,7 @@ export const parseMarkdownTasks = (text: string): ParsedMarkdownTask[] | null =>
   }
 
   // Find the minimum indentation level to normalize
-  const minIndentLevel = Math.min(...parsedLines.map((line) => line.indentLevel));
+  const minIndentLevel = findMinIndentLevel(parsedLines);
 
   // Normalize indentation levels by subtracting the minimum
   parsedLines.forEach((line) => {
diff --git a/src/assets/i18n/en.json b/src/assets/i18n/en.json
index 1c3060221d..508c880625 100644
--- a/src/assets/i18n/en.json
+++ b/src/assets/i18n/en.json
@@ -22,6 +22,7 @@
   },
   "CONFIRM": {
     "AUTO_FIX": "Your data seems to be damaged (\"{{validityError}}\"). Do you want to try to automatically fix it? This may result in partial data loss.",
+    "DELETE_SECTION": "Are you sure you want to delete this section? Tasks in it will be moved to the task list.",
     "RELOAD_AFTER_IDB_ERROR": "Database Error - App Will Restart\n\nSuper Productivity cannot save data! This is usually caused by:\n• Low disk space (most common)\n• App update in background\n• Linux Snap users: run 'snap set core experimental.refresh-app-awareness=true'\n\nYour recent changes may not have been saved. Please free up disk space if low. The app will restart after you close this dialog.",
     "RESTORE_FILE_BACKUP": "There seems to be NO DATA, but there are backups available at \"{{dir}}\". Do you want to restore the latest backup from {{from}}?",
     "RESTORE_FILE_BACKUP_ANDROID": "There seems to be NO DATA, but there is a backup available. Do you want to load it?",
@@ -2408,6 +2409,7 @@
   },
   "MH": {
     "ADD_NEW_TASK": "Add new Task",
+    "ADD_SECTION": "Add Section",
     "ALL_PLANNED_LIST": "Upcoming",
     "BOARDS": "Boards",
     "COPY_TASK_LIST_MARKDOWN": "Copy to clipboard",
@@ -2740,6 +2742,8 @@
   "WW": {
     "ADD_MORE": "Add more",
     "ADD_SCHEDULED_FOR_TOMORROW": "Add tasks planned for tomorrow ({{nr}})",
+    "ADD_SECTION_TITLE": "Add Section",
+    "SECTION_OPTIONS": "Section options",
     "DONE_TASKS": "Completed Tasks",
     "DONE_TASKS_IN_ARCHIVE": "There are currently no completed tasks here, but there are some already archived.",
     "ESTIMATE_REMAINING": "Estimate remaining:",
@@ -2750,6 +2754,7 @@
     "NO_DONE_TASKS": "There are currently no completed tasks",
     "NO_PLANNED_TASK_ALL_DONE": "all tasks completed",
     "NO_PLANNED_TASKS": "No tasks planned",
+    "NO_TASKS_IN_MAIN_LIST": "All tasks are organized into sections",
     "RECURRING_TASKS": "Recurring Tasks",
     "RESET_BREAK_TIMER": "Reset without break timer",
     "TIME_ESTIMATED": "Time estimated:",