diff --git a/docs/superpowers/plans/2026-06-08-multi-record-plan-cells.md b/docs/superpowers/plans/2026-06-08-multi-record-plan-cells.md
new file mode 100644
index 0000000..34cd22c
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-08-multi-record-plan-cells.md
@@ -0,0 +1,1524 @@
+# Multi-record Plan Cells Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Let a work-plan cell (one person, one day) hold up to 3 records — additive assignments plus one-day exceptions — instead of collapsing to a single record.
+
+**Architecture:** No DB migration. The two existing tables stay: `work_plan_entries` (ranges = additive layer) and `work_plan_overrides` (single-day = exception layer that replaces a range for that day). `resolveCell`/`resolveGrid` change from returning one record to returning an array of 0–3 (overrides-for-the-day if any, else entries-covering-the-day, newest-first, capped at 3). A `MAX_RECORDS_PER_CELL = 3` constant is enforced per layer on create. The grid renders the records stacked; clicking an occupied cell opens a "day panel" that lists records with per-record edit/delete + add. The dashboard "today" card shows up to 3.
+
+**Tech Stack:** Fastify 5 + Prisma (MySQL), React 18 + MUI v7, TanStack Query, Vitest (server-side, real test DB). Spec: `docs/superpowers/specs/2026-06-08-multi-record-plan-cells-design.md`.
+
+**Gates (run after every task that changes code):** `npx tsc -b --noEmit`, `npm run build`, `npx vitest run`. The frontend has **no component-test harness** (server-side tests only, per CLAUDE.md), so frontend-only tasks are gated by `tsc -b` + `build` + a manual Chrome check rather than a failing-test-first step.
+
+---
+
+## File Structure
+
+**Backend**
+
+- `src/services/plan.service.ts` — add `MAX_RECORDS_PER_CELL`; `resolveCell`/`resolveGrid` → arrays; cap in `createEntry`; `createOverride` additive-with-cap; trim `Result` type.
+- `src/routes/admin/plan.ts` — drop the `replacedData` audit branch in `POST /overrides`.
+- `src/routes/admin/dashboard.ts` — `today_plan` becomes an array.
+
+**Frontend**
+
+- `src/admin/lib/queries/plan.ts` — `GridData.cells` value type → `ResolvedCell[]`.
+- `src/admin/hooks/usePlanWork.ts` — optimistic patch helpers + mutation handlers + rollback + `getCell`/`getCells` work on arrays.
+- `src/admin/components/PlanGrid.tsx` — render up to 3 stacked records; `onCellClick` passes the array.
+- `src/admin/components/PlanRangeChips.tsx` — `showNote` prop (note only when single record).
+- `src/admin/components/PlanCellModal.tsx` — new `day` panel mode.
+- `src/admin/pages/PlanWork.tsx` — cell-click opens the day panel; mutation wrappers scan arrays.
+- `src/admin/components/dashboard/DashTodayPlan.tsx` + `src/admin/pages/Dashboard.tsx` — render up to 3.
+
+**Tests**
+
+- `src/__tests__/plan.test.ts` — update for the array shape; add cap + additive tests.
+
+---
+
+## Task 1: Backend — cap enforcement + additive overrides
+
+**Files:**
+
+- Modify: `src/services/plan.service.ts`
+- Modify: `src/routes/admin/plan.ts:316-354` (`POST /overrides`)
+- Test: `src/__tests__/plan.test.ts`
+
+This task does **not** change return shapes (resolve still returns a single record), so the frontend is untouched and keeps working. It only changes write-side rules: entries get a per-day cap, overrides become additive-with-cap (no more replace).
+
+- [ ] **Step 1: Update the two `createOverride` tests + add cap tests (write the new expectations first)**
+
+In `src/__tests__/plan.test.ts`, **replace** the test `"creates an override and returns { data, oldData: null, replacedData: null }"` (lines ~442-459) with this version (drops the `replacedData` assertion):
+
+```ts
+it("creates an override and returns { data, oldData: null }", async () => {
+  const result = await createOverride(
+    {
+      user_id: adminUserId,
+      shift_date: "2099-10-01",
+      category: "leave",
+      note: `${N}day off`,
+    },
+    adminUserId,
+    false,
+  );
+  expect("data" in result).toBe(true);
+  if ("data" in result) {
+    expect(result.data.note).toBe(`${N}day off`);
+    expect(result.oldData).toBeNull();
+  }
+});
+```
+
+**Replace** the test `"soft-deletes the existing override and reports it in replacedData"` (lines ~461-493) with this additive + cap version:
+
+```ts
+it("stacks additive overrides and caps at MAX_RECORDS_PER_CELL", async () => {
+  for (let i = 0; i < 3; i++) {
+    const r = await createOverride(
+      {
+        user_id: adminUserId,
+        shift_date: "2099-10-02",
+        category: "leave",
+        note: `${N}o${i}`,
+      },
+      adminUserId,
+      false,
+    );
+    expect("data" in r).toBe(true);
+  }
+  // A 4th record on the same day is rejected by the cap.
+  const fourth = await createOverride(
+    {
+      user_id: adminUserId,
+      shift_date: "2099-10-02",
+      category: "leave",
+      note: `${N}o3`,
+    },
+    adminUserId,
+    false,
+  );
+  expect("error" in fourth).toBe(true);
+  if ("error" in fourth) expect(fourth.status).toBe(400);
+  // All three earlier overrides remain active — no replace happened.
+  const active = await prisma.work_plan_overrides.findMany({
+    where: {
+      user_id: adminUserId,
+      shift_date: new Date("2099-10-02"),
+      is_deleted: false,
+    },
+  });
+  expect(active.length).toBe(3);
+});
+```
+
+Add this test to the `describe("plan.service.createEntry", ...)` block (after the existing tests, before its closing `});`):
+
+```ts
+it("rejects a 4th entry covering a day already at the cap", async () => {
+  for (let i = 0; i < 3; i++) {
+    const r = await createEntry(
+      {
+        user_id: adminUserId,
+        date_from: "2099-07-20",
+        date_to: "2099-07-20",
+        category: "work",
+        note: `${N}e${i}`,
+      },
+      adminUserId,
+      false,
+    );
+    expect("data" in r).toBe(true);
+  }
+  const fourth = await createEntry(
+    {
+      user_id: adminUserId,
+      date_from: "2099-07-20",
+      date_to: "2099-07-20",
+      category: "work",
+      note: `${N}e3`,
+    },
+    adminUserId,
+    false,
+  );
+  expect("error" in fourth).toBe(true);
+  if ("error" in fourth) expect(fourth.status).toBe(400);
+});
+```
+
+- [ ] **Step 2: Run the tests to verify they fail**
+
+Run: `npx vitest run src/__tests__/plan.test.ts`
+Expected: FAIL — the additive/cap tests fail (createOverride still replaces; createEntry has no cap), and `replacedData` is no longer asserted but the old replace test is gone.
+
+- [ ] **Step 3: Add the constant + entry-cap helper in `plan.service.ts`**
+
+Near the top of `src/services/plan.service.ts`, after the `toDateOnly` helper (around line 402), add:
+
+```ts
+/** Maximum number of records (entries OR overrides) shown per cell per day. */
+export const MAX_RECORDS_PER_CELL = 3;
+
+/**
+ * Returns { error, status } if creating an entry over [dateFromStr, dateToStr]
+ * would push any single day past MAX_RECORDS_PER_CELL active entries for the
+ * user. Names the first offending date. Counts entries regardless of whether an
+ * override currently hides them (simpler and predictable).
+ */
+async function assertEntryCapAvailable(
+  userId: number,
+  dateFromStr: string,
+  dateToStr: string,
+): Promise<{ error: string; status: number } | null> {
+  const from = toDateOnly(dateFromStr);
+  const to = toDateOnly(dateToStr);
+  const existing = await prisma.work_plan_entries.findMany({
+    where: {
+      user_id: userId,
+      is_deleted: false,
+      date_from: { lte: to },
+      date_to: { gte: from },
+    },
+    select: { date_from: true, date_to: true },
+  });
+  for (let d = new Date(from); d <= to; d.setUTCDate(d.getUTCDate() + 1)) {
+    const day = new Date(d);
+    const count = existing.filter(
+      (e) => e.date_from <= day && e.date_to >= day,
+    ).length;
+    if (count >= MAX_RECORDS_PER_CELL) {
+      return {
+        error: `Na den ${day.toISOString().slice(0, 10)} jsou již ${MAX_RECORDS_PER_CELL} záznamy (maximum).`,
+        status: 400,
+      };
+    }
+  }
+  return null;
+}
+```
+
+- [ ] **Step 4: Call the entry-cap helper in `createEntry`**
+
+In `createEntry` (around line 442), insert the cap check immediately after the existing `assertActiveCategory` check and before `prisma.work_plan_entries.create`:
+
+```ts
+const catErr = await assertActiveCategory(input.category);
+if (catErr) return catErr;
+
+const capErr = await assertEntryCapAvailable(
+  input.user_id,
+  input.date_from,
+  input.date_to,
+);
+if (capErr) return capErr;
+```
+
+- [ ] **Step 5: Make `createOverride` additive-with-cap (drop replace)**
+
+Replace the body of `createOverride` from the `const date = toDateOnly(...)` line through the `return { ... replacedData ... }` (lines ~613-681) with:
+
+```ts
+const date = toDateOnly(input.shift_date);
+
+// Additive up to MAX_RECORDS_PER_CELL. (This previously REPLACED the existing
+// override; multi-record cells stack instead.) count+create runs in one
+// transaction; a concurrent create could in theory add one extra row, but
+// resolve display caps at MAX_RECORDS_PER_CELL so that is benign.
+let created;
+try {
+  created = await prisma.$transaction(async (tx) => {
+    const count = await tx.work_plan_overrides.count({
+      where: { user_id: input.user_id, shift_date: date, is_deleted: false },
+    });
+    if (count >= MAX_RECORDS_PER_CELL) {
+      throw Object.assign(new Error("cap"), { __cap: true });
+    }
+    return tx.work_plan_overrides.create({
+      data: {
+        user_id: input.user_id,
+        shift_date: date,
+        project_id: input.project_id ?? null,
+        category: input.category,
+        note: input.note,
+        created_by: actorUserId,
+      },
+    });
+  });
+} catch (e) {
+  if (e && typeof e === "object" && "__cap" in e) {
+    return {
+      error: `Na tento den jsou již ${MAX_RECORDS_PER_CELL} záznamy (maximum).`,
+      status: 400,
+    };
+  }
+  throw e;
+}
+
+const { userName, projectName } = await resolvePlanLabels(
+  created.user_id,
+  created.project_id,
+);
+const description = buildPlanAuditDescription({
+  userName,
+  categoryLabel: await resolveCategoryLabel(created.category),
+  projectName,
+  dateFrom: input.shift_date,
+  dateTo: input.shift_date,
+  force,
+});
+
+return { data: created, oldData: null, description };
+```
+
+- [ ] **Step 6: Trim the `Result` type (remove replaced\* fields)**
+
+In `plan.service.ts`, change the `Result<T>` success branch (around lines 387-397) to drop `replacedData` and `replacedDescription`:
+
+```ts
+export type Result<T> =
+  | {
+      data: T;
+      oldData: unknown | null;
+      /** Human-readable Czech subject for the audit-log row. */
+      description?: string;
+    }
+  | { error: string; status: number };
+```
+
+Update its doc-comment above to remove the paragraph describing `replacedData`.
+
+- [ ] **Step 7: Remove the `replacedData` audit branch in the override route**
+
+In `src/routes/admin/plan.ts`, inside `POST /plan/overrides` (lines ~330-342), delete the entire `if (result.replacedData) { ... }` block. The handler keeps only the single create audit-log call that follows.
+
+- [ ] **Step 8: Run the tests to verify they pass**
+
+Run: `npx vitest run src/__tests__/plan.test.ts`
+Expected: PASS (all plan tests, including the new additive + cap tests).
+
+- [ ] **Step 9: Gate + commit**
+
+```bash
+npx tsc -b --noEmit
+npx vitest run
+git add src/services/plan.service.ts src/routes/admin/plan.ts src/__tests__/plan.test.ts
+git commit -m "feat(plan): per-cell record cap (3) + additive overrides"
+```
+
+---
+
+## Task 2: Backend resolve → arrays + coordinated frontend shape change
+
+**Files:**
+
+- Modify: `src/services/plan.service.ts` (`resolveCell`, `resolveGrid`)
+- Modify: `src/routes/admin/dashboard.ts`
+- Modify: `src/admin/lib/queries/plan.ts`
+- Modify: `src/admin/hooks/usePlanWork.ts`
+- Modify: `src/admin/components/PlanGrid.tsx`
+- Modify: `src/admin/pages/PlanWork.tsx`
+- Modify: `src/admin/components/dashboard/DashTodayPlan.tsx`
+- Modify: `src/admin/pages/Dashboard.tsx`
+- Test: `src/__tests__/plan.test.ts`
+
+The resolve return-shape change is atomic across server + client (the cell type is a TS lie over runtime JSON; tsc won't catch a mismatch, so both sides must move together). This task keeps the app **behaving as before** — the grid and cell editor still show/act on the _first_ (primary) record — while the data is now an array. Stacked rendering (Task 3) and the day panel (Task 4) build on top. The dashboard card gets full stacking here (it's small).
+
+- [ ] **Step 1: Rewrite the resolve tests for the array shape (write expectations first)**
+
+In `src/__tests__/plan.test.ts`, replace the `describe("plan.service.resolveCell", ...)` block (lines ~77-148) with:
+
+```ts
+describe("plan.service.resolveCell", () => {
+  it("returns [] when nothing covers the date", async () => {
+    const result = await resolveCell(adminUserId, "2099-01-01");
+    expect(result).toEqual([]);
+  });
+
+  it("returns the entry that covers the date", async () => {
+    await prisma.work_plan_entries.create({
+      data: {
+        user_id: adminUserId,
+        date_from: new Date("2099-06-01"),
+        date_to: new Date("2099-06-10"),
+        category: "work",
+        note: `${N}PLC upgrade`,
+        created_by: adminUserId,
+      },
+    });
+    const result = await resolveCell(adminUserId, "2099-06-05");
+    expect(result.length).toBe(1);
+    expect(result[0].source).toBe("entry");
+    expect(result[0].note).toBe(`${N}PLC upgrade`);
+    expect(result[0].rangeFrom).toBe("2099-06-01");
+    expect(result[0].rangeTo).toBe("2099-06-10");
+  });
+
+  it("returns overrides (entries hidden) when an override exists", async () => {
+    await prisma.work_plan_entries.create({
+      data: {
+        user_id: adminUserId,
+        date_from: new Date("2099-06-01"),
+        date_to: new Date("2099-06-10"),
+        category: "work",
+        note: `${N}PLC upgrade`,
+        created_by: adminUserId,
+      },
+    });
+    await prisma.work_plan_overrides.create({
+      data: {
+        user_id: adminUserId,
+        shift_date: new Date("2099-06-05"),
+        category: "leave",
+        note: `${N}Volno po noční`,
+        created_by: adminUserId,
+      },
+    });
+    const result = await resolveCell(adminUserId, "2099-06-05");
+    expect(result.length).toBe(1);
+    expect(result[0].source).toBe("override");
+    expect(result[0].note).toBe(`${N}Volno po noční`);
+  });
+
+  it("returns multiple additive entries newest-first", async () => {
+    await prisma.work_plan_entries.create({
+      data: {
+        user_id: adminUserId,
+        date_from: new Date("2099-06-01"),
+        date_to: new Date("2099-06-10"),
+        category: "work",
+        note: `${N}first`,
+        created_by: adminUserId,
+      },
+    });
+    await prisma.work_plan_entries.create({
+      data: {
+        user_id: adminUserId,
+        date_from: new Date("2099-06-05"),
+        date_to: new Date("2099-06-05"),
+        category: "work",
+        note: `${N}second`,
+        created_by: adminUserId,
+      },
+    });
+    const result = await resolveCell(adminUserId, "2099-06-05");
+    expect(result.length).toBe(2);
+    expect(result[0].note).toBe(`${N}second`); // newest first
+  });
+
+  it("caps the returned records at MAX_RECORDS_PER_CELL", async () => {
+    for (let i = 0; i < 4; i++) {
+      await prisma.work_plan_overrides.create({
+        data: {
+          user_id: adminUserId,
+          shift_date: new Date("2099-06-06"),
+          category: "leave",
+          note: `${N}cap${i}`,
+          created_by: adminUserId,
+        },
+      });
+    }
+    const result = await resolveCell(adminUserId, "2099-06-06");
+    expect(result.length).toBe(3);
+  });
+
+  it("ignores soft-deleted entries and overrides", async () => {
+    await prisma.work_plan_entries.create({
+      data: {
+        user_id: adminUserId,
+        date_from: new Date("2099-06-01"),
+        date_to: new Date("2099-06-10"),
+        category: "work",
+        note: `${N}deleted entry`,
+        is_deleted: true,
+        created_by: adminUserId,
+      },
+    });
+    const result = await resolveCell(adminUserId, "2099-06-05");
+    expect(result).toEqual([]);
+  });
+});
+```
+
+In the `describe("plan.service.resolveGrid", ...)` block, update the cell accessors to index `[0]` and expect `[]` for empty days. Replace lines ~166-198 assertions:
+
+```ts
+const cells = await resolveGrid([adminUserId], "2099-06-01", "2099-06-05");
+expect(cells[adminUserId]["2099-06-01"][0]?.note).toBe(`${N}A`);
+expect(cells[adminUserId]["2099-06-02"][0]?.note).toBe(`${N}A`);
+expect(cells[adminUserId]["2099-06-03"][0]?.note).toBe(`${N}A`);
+expect(cells[adminUserId]["2099-06-04"]).toEqual([]);
+expect(cells[adminUserId]["2099-06-05"]).toEqual([]);
+```
+
+and for the override-on-covered-day test:
+
+```ts
+const cells = await resolveGrid([adminUserId], "2099-06-01", "2099-06-03");
+expect(cells[adminUserId]["2099-06-01"][0]?.note).toBe(`${N}A`);
+expect(cells[adminUserId]["2099-06-02"][0]?.note).toBe(`${N}B`);
+expect(cells[adminUserId]["2099-06-03"][0]?.note).toBe(`${N}A`);
+```
+
+In the HTTP grid test (line ~813), change:
+
+```ts
+expect(body.data.cells[adminUserId]["2097-06-01"][0].note).toBe(
+  `${N}grid test`,
+);
+```
+
+- [ ] **Step 2: Run resolve tests to verify they fail**
+
+Run: `npx vitest run src/__tests__/plan.test.ts`
+Expected: FAIL (resolveCell returns an object/null, not an array).
+
+- [ ] **Step 3: Rewrite `resolveCell` to return an array**
+
+Replace `resolveCell` (lines ~122-187) in `src/services/plan.service.ts` with:
+
+```ts
+export async function resolveCell(
+  userId: number,
+  dateStr: string,
+): Promise<ResolvedCell[]> {
+  const date = new Date(dateStr);
+
+  const overrides = await prisma.work_plan_overrides.findMany({
+    where: { user_id: userId, shift_date: date, is_deleted: false },
+    orderBy: { created_at: "desc" },
+    take: MAX_RECORDS_PER_CELL,
+    include: { projects: projectSelect },
+  });
+  if (overrides.length > 0) {
+    return overrides.map((o) => ({
+      source: "override" as const,
+      entryId: null,
+      overrideId: o.id,
+      user_id: o.user_id,
+      shift_date: dateStr,
+      project_id: o.project_id,
+      ...projectFields(o.projects),
+      category: o.category,
+      note: o.note,
+      rangeFrom: null,
+      rangeTo: null,
+    }));
+  }
+
+  const entries = await prisma.work_plan_entries.findMany({
+    where: {
+      user_id: userId,
+      date_from: { lte: date },
+      date_to: { gte: date },
+      is_deleted: false,
+    },
+    orderBy: { created_at: "desc" },
+    take: MAX_RECORDS_PER_CELL,
+    include: { projects: projectSelect },
+  });
+  return entries.map((entry) => ({
+    source: "entry" as const,
+    entryId: entry.id,
+    overrideId: null,
+    user_id: entry.user_id,
+    shift_date: dateStr,
+    project_id: entry.project_id,
+    ...projectFields(entry.projects),
+    category: entry.category,
+    note: entry.note,
+    rangeFrom: entry.date_from.toISOString().slice(0, 10),
+    rangeTo: entry.date_to.toISOString().slice(0, 10),
+  }));
+}
+```
+
+- [ ] **Step 4: Rewrite `resolveGrid` to return arrays**
+
+Replace `resolveGrid` (lines ~197-290) with:
+
+```ts
+export async function resolveGrid(
+  userIds: number[],
+  dateFromStr: string,
+  dateToStr: string,
+): Promise<Record<number, Record<string, ResolvedCell[]>>> {
+  const dateFrom = new Date(dateFromStr);
+  const dateTo = new Date(dateToStr);
+
+  const [entries, overrides] = await Promise.all([
+    prisma.work_plan_entries.findMany({
+      where: {
+        user_id: { in: userIds },
+        is_deleted: false,
+        date_from: { lte: dateTo },
+        date_to: { gte: dateFrom },
+      },
+      orderBy: { created_at: "desc" },
+      include: { projects: projectSelect },
+    }),
+    prisma.work_plan_overrides.findMany({
+      where: {
+        user_id: { in: userIds },
+        is_deleted: false,
+        shift_date: { gte: dateFrom, lte: dateTo },
+      },
+      orderBy: { created_at: "desc" },
+      include: { projects: projectSelect },
+    }),
+  ]);
+
+  const dates: string[] = [];
+  for (
+    let d = new Date(dateFrom);
+    d <= dateTo;
+    d.setUTCDate(d.getUTCDate() + 1)
+  ) {
+    dates.push(d.toISOString().slice(0, 10));
+  }
+
+  const result: Record<number, Record<string, ResolvedCell[]>> = {};
+  for (const uid of userIds) {
+    result[uid] = {};
+    for (const dateStr of dates) {
+      const day = new Date(dateStr);
+      const dayOverrides = overrides
+        .filter(
+          (o) =>
+            o.user_id === uid &&
+            o.shift_date.toISOString().slice(0, 10) === dateStr,
+        )
+        .slice(0, MAX_RECORDS_PER_CELL);
+      if (dayOverrides.length > 0) {
+        result[uid][dateStr] = dayOverrides.map((o) => ({
+          source: "override" as const,
+          entryId: null,
+          overrideId: o.id,
+          user_id: o.user_id,
+          shift_date: dateStr,
+          project_id: o.project_id,
+          ...projectFields(o.projects),
+          category: o.category,
+          note: o.note,
+          rangeFrom: null,
+          rangeTo: null,
+        }));
+        continue;
+      }
+      const dayEntries = entries
+        .filter(
+          (e) => e.user_id === uid && e.date_from <= day && e.date_to >= day,
+        )
+        .slice(0, MAX_RECORDS_PER_CELL);
+      result[uid][dateStr] = dayEntries.map((e) => ({
+        source: "entry" as const,
+        entryId: e.id,
+        overrideId: null,
+        user_id: e.user_id,
+        shift_date: dateStr,
+        project_id: e.project_id,
+        ...projectFields(e.projects),
+        category: e.category,
+        note: e.note,
+        rangeFrom: e.date_from.toISOString().slice(0, 10),
+        rangeTo: e.date_to.toISOString().slice(0, 10),
+      }));
+    }
+  }
+
+  return result;
+}
+```
+
+- [ ] **Step 5: Update the dashboard route to build a `today_plan` array**
+
+In `src/routes/admin/dashboard.ts`, replace the `today_plan` block (lines ~51-67) with:
+
+```ts
+if (has("attendance.record") || has("attendance.manage")) {
+  const todayStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  const cells = await resolveCell(userId, todayStr);
+  result.today_plan = await Promise.all(
+    cells.map(async (cell) => {
+      const cat = await prisma.plan_categories.findUnique({
+        where: { key: cell.category },
+        select: { label: true, color: true },
+      });
+      return {
+        ...cell,
+        category_label: cat?.label ?? cell.category,
+        category_color: cat?.color ?? null,
+      };
+    }),
+  );
+}
+```
+
+- [ ] **Step 6: Update the frontend cell type**
+
+In `src/admin/lib/queries/plan.ts`, change the `GridData.cells` value type (line ~84):
+
+```ts
+cells: Record<number, Record<string, ResolvedCell[]>>;
+```
+
+- [ ] **Step 7: Make `usePlanWork` array-aware**
+
+In `src/admin/hooks/usePlanWork.ts`:
+
+(a) Change `patchCells` (lines ~149-169) to operate on arrays:
+
+```ts
+function patchCells(
+  key: readonly unknown[],
+  userId: number,
+  dates: string[],
+  mutator: (prev: ResolvedCell[]) => ResolvedCell[],
+): Record<string, ResolvedCell[]> | null {
+  const prev = snapshotGrid(key);
+  if (!prev) return null;
+  const userPrev = prev.cells[userId] ?? {};
+  const rolled: Record<string, ResolvedCell[]> = {};
+  const userNext: Record<string, ResolvedCell[]> = { ...userPrev };
+  for (const date of dates) {
+    rolled[date] = userPrev[date] ?? [];
+    userNext[date] = mutator(rolled[date]).slice(0, 3);
+  }
+  qc.setQueryData(key, {
+    ...prev,
+    cells: { ...prev.cells, [userId]: userNext },
+  });
+  return rolled;
+}
+```
+
+(b) `createEntry.onSuccess` (lines ~241-263) — prepend the new cell (newest-first):
+
+```ts
+const rolled = patchCells(currentGridKey, body.user_id, days, (prev) => [
+  makeEntryCell({
+    userId: body.user_id,
+    date: days[0],
+    projectId: body.project_id ?? null,
+    category: body.category,
+    note: body.note,
+    rangeFrom: body.date_from,
+    rangeTo: body.date_to,
+    entryId: id,
+  }),
+  ...prev,
+]);
+```
+
+(c) `updateEntry.onSuccess` (lines ~281-326) — replace the owner-scan loop and the `patchCells` mutator. The scan now checks arrays:
+
+```ts
+let ownerUserId: number | null = null;
+if (grid) {
+  for (const [uidStr, byDate] of Object.entries(grid.cells)) {
+    for (const cells of Object.values(byDate)) {
+      if (cells.some((c) => c.entryId === id)) {
+        ownerUserId = Number(uidStr);
+        break;
+      }
+    }
+    if (ownerUserId !== null) break;
+  }
+}
+if (ownerUserId !== null) {
+  const rolled = patchCells(currentGridKey, ownerUserId, days, (prev) => {
+    const existing = prev.find((c) => c.entryId === id) ?? null;
+    const updated = makeEntryCell({
+      userId: ownerUserId!,
+      date: days[0],
+      projectId:
+        body.project_id === undefined
+          ? (existing?.project_id ?? null)
+          : body.project_id,
+      category: body.category ?? existing?.category ?? "work",
+      note: body.note ?? existing?.note ?? "",
+      rangeFrom: body.date_from,
+      rangeTo: body.date_to,
+      entryId: id,
+    });
+    return [updated, ...prev.filter((c) => c.entryId !== id)];
+  });
+  (updateEntry as any)._rolled = rolled;
+}
+```
+
+(d) `deleteEntry.onSuccess` (lines ~334-361) — find by array membership, then remove the matching id from each day in the range:
+
+```ts
+const grid = qc.getQueryData<GridData>(currentGridKey as any);
+if (grid) {
+  for (const [uidStr, byDate] of Object.entries(grid.cells)) {
+    let range: { from: string; to: string } | null = null;
+    for (const cells of Object.values(byDate)) {
+      const hit = cells.find(
+        (c) => c.entryId === vars.id && c.rangeFrom && c.rangeTo,
+      );
+      if (hit) {
+        range = { from: hit.rangeFrom!, to: hit.rangeTo! };
+        break;
+      }
+    }
+    if (range) {
+      const days = eachDay(range.from, range.to);
+      const rolled = patchCells(currentGridKey, Number(uidStr), days, (prev) =>
+        prev.filter((c) => c.entryId !== vars.id),
+      );
+      (deleteEntry as any)._rolled = rolled;
+      break;
+    }
+  }
+}
+```
+
+(e) `createOverride.onSuccess` (lines ~372-389) — prepend:
+
+```ts
+const rolled = patchCells(
+  currentGridKey,
+  vars.user_id,
+  [vars.shift_date],
+  (prev) => [
+    makeOverrideCell({
+      userId: vars.user_id,
+      date: vars.shift_date,
+      projectId: vars.project_id ?? null,
+      category: vars.category,
+      note: vars.note,
+      overrideId: id,
+    }),
+    ...prev,
+  ],
+);
+```
+
+(f) `updateOverride.onSuccess` (lines ~408-436) — array scan + replace:
+
+```ts
+const grid = qc.getQueryData<GridData>(currentGridKey as any);
+if (grid) {
+  for (const [uidStr, byDate] of Object.entries(grid.cells)) {
+    for (const [date, cells] of Object.entries(byDate)) {
+      if (cells.some((c) => c.overrideId === vars.id)) {
+        const rolled = patchCells(
+          currentGridKey,
+          Number(uidStr),
+          [date],
+          (prev) => {
+            const existing = prev.find((c) => c.overrideId === vars.id) ?? null;
+            const updated = makeOverrideCell({
+              userId: Number(uidStr),
+              date,
+              projectId: vars.body.project_id ?? existing?.project_id ?? null,
+              category: vars.body.category ?? existing?.category ?? "work",
+              note: vars.body.note ?? existing?.note ?? "",
+              overrideId: vars.id,
+            });
+            return [updated, ...prev.filter((c) => c.overrideId !== vars.id)];
+          },
+        );
+        (updateOverride as any)._rolled = rolled;
+        break;
+      }
+    }
+  }
+}
+```
+
+(g) `deleteOverride.onSuccess` (lines ~445-463) — array scan + remove:
+
+```ts
+const grid = qc.getQueryData<GridData>(currentGridKey as any);
+if (grid) {
+  for (const [uidStr, byDate] of Object.entries(grid.cells)) {
+    for (const [date, cells] of Object.entries(byDate)) {
+      if (cells.some((c) => c.overrideId === vars.id)) {
+        const rolled = patchCells(
+          currentGridKey,
+          Number(uidStr),
+          [date],
+          (prev) => prev.filter((c) => c.overrideId !== vars.id),
+        );
+        (deleteOverride as any)._rolled = rolled;
+        break;
+      }
+    }
+  }
+}
+```
+
+(h) `rollbackMutation` (lines ~473-490) — change the stash + cell types to arrays:
+
+```ts
+function rollbackMutation(mutation: unknown, userId: number) {
+  const stash = mutation as {
+    _rolled?: Record<string, ResolvedCell[]> | null;
+  };
+  if (!stash._rolled) return;
+  const prev = qc.getQueryData<GridData>(currentGridKey as any);
+  if (!prev) return;
+  const userPrev = prev.cells[userId] ?? {};
+  const userNext = { ...userPrev };
+  for (const [date, cells] of Object.entries(stash._rolled)) {
+    userNext[date] = cells;
+  }
+  qc.setQueryData(currentGridKey, {
+    ...prev,
+    cells: { ...prev.cells, [userId]: userNext },
+  });
+  stash._rolled = null;
+}
+```
+
+(i) `getCell` (lines ~521-527) — keep returning the primary record for now, and add `getCells` for the array:
+
+```ts
+export function getCells(
+  grid: GridData | undefined,
+  userId: number,
+  date: string,
+): ResolvedCell[] {
+  return grid?.cells?.[userId]?.[date] ?? [];
+}
+
+export function getCell(
+  grid: GridData | undefined,
+  userId: number,
+  date: string,
+): ResolvedCell | null {
+  return getCells(grid, userId, date)[0] ?? null;
+}
+```
+
+- [ ] **Step 8: Make `PlanGrid` read the array (primary record for now)**
+
+In `src/admin/components/PlanGrid.tsx`, in the cell-render loop (around line 532) change:
+
+```ts
+const cellArr = data.cells[u.id]?.[date] ?? [];
+const cell = cellArr[0] ?? null;
+```
+
+Leave the rest of the loop unchanged (it already keys off `cell`). The `onCellClick(u.id, date, cell)` call stays — clicking still opens the primary record (stacked rendering and array-passing come in Tasks 3–4).
+
+- [ ] **Step 9: Make `PlanWork` mutation-wrapper scans array-aware**
+
+In `src/admin/pages/PlanWork.tsx`, the wrappers `updateEntryFn`, `deleteEntryFn`, `updateOverrideFn`, `deleteOverrideFn` each scan `grid.cells` with `if (cell && cell.entryId === id)` / `cell.overrideId === id`. In every such loop, the inner value is now an array — change the destructure + predicate. Replace each occurrence of this shape:
+
+```ts
+for (const [date, cell] of Object.entries(byDate)) {
+  if (cell && cell.entryId === id) {
+    userId = Number(uidStr);
+    firstDate = body.date_from ?? date;
+    break;
+  }
+}
+```
+
+with the array form (matching the field used at that site — `entryId` for entry wrappers, `overrideId` for override wrappers; `rangeFrom` is read from the found record in `deleteEntryFn`):
+
+```ts
+for (const [date, cells] of Object.entries(byDate)) {
+  const hit = cells.find((c) => c.entryId === id);
+  if (hit) {
+    userId = Number(uidStr);
+    firstDate = body.date_from ?? date;
+    break;
+  }
+}
+```
+
+For `deleteEntryFn`, set `firstDate = hit.rangeFrom ?? date;`. For the override wrappers, use `c.overrideId === id` and `date = d`.
+
+- [ ] **Step 10: Dashboard card — render up to 3 (full stacking here)**
+
+Replace `src/admin/components/dashboard/DashTodayPlan.tsx` so it accepts an array and stacks. Keep the existing single-record card markup, extracted into an inner row and mapped:
+
+```tsx
+import Box from "@mui/material/Box";
+import Typography from "@mui/material/Typography";
+import { Card } from "../../ui";
+import { formatDate } from "../../utils/formatters";
+
+/** One resolved plan record for today (see GET /api/admin/dashboard). */
+export interface TodayPlan {
+  shift_date: string;
+  category: string;
+  category_label: string;
+  category_color: string | null;
+  project_id: number | null;
+  project_number: string | null;
+  project_name: string | null;
+  note: string;
+  source: "entry" | "override";
+  rangeFrom: string | null;
+  rangeTo: string | null;
+}
+
+function projectLabel(p: TodayPlan): string {
+  const parts = [p.project_number, p.project_name].filter(Boolean);
+  return parts.length > 0 ? parts.join(" — ") : "Bez projektu";
+}
+
+function PlanRow({ plan }: { plan: TodayPlan }) {
+  const color = plan.category_color || "var(--mui-palette-primary-main)";
+  return (
+    <Box sx={{ display: "flex", flexDirection: "column", gap: 1 }}>
+      <Box
+        sx={{ display: "flex", alignItems: "center", gap: 1, flexWrap: "wrap" }}
+      >
+        <Box
+          sx={{
+            display: "inline-flex",
+            alignItems: "center",
+            gap: 0.75,
+            px: 1.25,
+            py: 0.5,
+            borderRadius: 999,
+            border: 1,
+            borderColor: "divider",
+            bgcolor: `color-mix(in srgb, ${color} 12%, transparent)`,
+          }}
+        >
+          <Box
+            sx={{
+              width: 10,
+              height: 10,
+              borderRadius: "50%",
+              bgcolor: color,
+              flexShrink: 0,
+            }}
+          />
+          <Typography
+            component="span"
+            sx={{ fontWeight: 700, fontSize: "0.8rem" }}
+          >
+            {plan.category_label}
+          </Typography>
+        </Box>
+        {plan.rangeFrom && plan.rangeTo && plan.rangeFrom !== plan.rangeTo && (
+          <Typography variant="caption" color="text.secondary">
+            součást rozsahu {formatDate(plan.rangeFrom)} –{" "}
+            {formatDate(plan.rangeTo)}
+          </Typography>
+        )}
+      </Box>
+      <Typography variant="h6" sx={{ lineHeight: 1.25 }}>
+        {projectLabel(plan)}
+      </Typography>
+      {plan.note && (
+        <Typography variant="body2" color="text.secondary">
+          {plan.note}
+        </Typography>
+      )}
+    </Box>
+  );
+}
+
+/** "Vaše dnešní zařazení" — the logged-in user's resolved plan record(s) for
+ * today (up to 3). Empty array = nothing scheduled. */
+export default function DashTodayPlan({ plans }: { plans: TodayPlan[] }) {
+  return (
+    <Card sx={{ mb: 3 }}>
+      <Typography
+        variant="subtitle2"
+        sx={{ mb: 1.5, fontWeight: 600, color: "text.secondary" }}
+      >
+        Vaše dnešní zařazení
+      </Typography>
+      {plans.length > 0 ? (
+        <Box sx={{ display: "flex", flexDirection: "column", gap: 2 }}>
+          {plans.map((p, i) => (
+            <Box
+              key={i}
+              sx={{
+                pt: i === 0 ? 0 : 2,
+                borderTop: i === 0 ? 0 : 1,
+                borderColor: "divider",
+              }}
+            >
+              <PlanRow plan={p} />
+            </Box>
+          ))}
+        </Box>
+      ) : (
+        <Typography variant="body2" color="text.secondary">
+          Pro dnešek nemáte naplánováno.
+        </Typography>
+      )}
+    </Card>
+  );
+}
+```
+
+In `src/admin/pages/Dashboard.tsx`: change the `DashData` field (line 75) to `today_plan?: TodayPlan[];` and the render (line 328) to `<DashTodayPlan plans={dashData?.today_plan ?? []} />`.
+
+- [ ] **Step 11: Gate (tests + typecheck + build)**
+
+```bash
+npx vitest run
+npx tsc -b --noEmit
+npm run build
+```
+
+Expected: vitest PASS, tsc exit 0, build success.
+
+- [ ] **Step 12: Commit**
+
+```bash
+git add src/services/plan.service.ts src/routes/admin/dashboard.ts src/admin/lib/queries/plan.ts src/admin/hooks/usePlanWork.ts src/admin/components/PlanGrid.tsx src/admin/pages/PlanWork.tsx src/admin/components/dashboard/DashTodayPlan.tsx src/admin/pages/Dashboard.tsx src/__tests__/plan.test.ts
+git commit -m "feat(plan): resolveCell/resolveGrid return arrays; dashboard shows up to 3"
+```
+
+---
+
+## Task 3: Grid — render up to 3 stacked records
+
+**Files:**
+
+- Modify: `src/admin/components/PlanRangeChips.tsx`
+- Modify: `src/admin/components/PlanGrid.tsx`
+
+Frontend-only and visual; no component test harness exists, so the gate is `tsc -b` + `build` + a Chrome check. After Task 2 the cell still shows only the primary record — this task stacks all of them.
+
+- [ ] **Step 1: Add a `showNote` prop to `PlanRangeChips`**
+
+In `src/admin/components/PlanRangeChips.tsx`, add `showNote?: boolean` to `Props` and gate the note. Change the interface and the note line:
+
+```tsx
+interface Props {
+  cell: ResolvedCell | null;
+  project: Project | null;
+  readonly?: boolean;
+  categoryLabel: string;
+  showNote?: boolean;
+}
+```
+
+and the note render (line ~39):
+
+```tsx
+{
+  showNote !== false && cell.note && (
+    <div className="plan-cell-note">{cell.note}</div>
+  );
+}
+```
+
+- [ ] **Step 2: Stack the records in `PlanGrid`**
+
+In `src/admin/components/PlanGrid.tsx`, replace the single `<PlanRangeChips ... />` inside the cell `<button>` (lines ~583-596) with a stacked map over `cellArr`. Also set `--cat-color` per record rather than per cell, and key the button styling off the first record. Replace the button's `style` + children:
+
+```tsx
+<button
+  type="button"
+  className={cls}
+  style={
+    cell
+      ? ({ "--cat-color": catMap[cell.category]?.color } as CSSProperties)
+      : undefined
+  }
+  onClick={() => onCellClick(u.id, date, cellArr)}
+  aria-label={
+    cell
+      ? `${u.full_name}, ${date}, ${cellArr.length} ${cellArr.length === 1 ? "záznam" : "záznamy"}`
+      : isLocked
+        ? `${u.full_name}, ${date}, ${past ? "uplynulý den" : "prázdné"} — bez záznamu`
+        : `${u.full_name}, ${date}, prázdné — přidat záznam`
+  }
+>
+  {cellArr.map((c, i) => (
+    <Box
+      key={c.entryId ?? `o${c.overrideId}` ?? i}
+      className="plan-cell-record"
+      style={{ "--cat-color": catMap[c.category]?.color } as CSSProperties}
+    >
+      <PlanRangeChips
+        cell={c}
+        project={
+          c.project_id
+            ? (projects.find((p) => p.id === c.project_id) ?? null)
+            : null
+        }
+        readonly={!canEdit}
+        categoryLabel={planCategoryLabel(c.category, catMap)}
+        showNote={cellArr.length === 1}
+      />
+    </Box>
+  ))}
+</button>
+```
+
+`onCellClick` now passes the **array** `cellArr` — update its `Props` type in Step 3. The button keeps a single `--cat-color` (the first record's, for the left-tape `::before`); each `.plan-cell-record` then sets its own `--cat-color` for its chip. `cell` is `cellArr[0] ?? null` from Task 2 Step 8. `<Box>` is already imported in PlanGrid.tsx.
+
+- [ ] **Step 3: Update the `onCellClick` prop type**
+
+In `PlanGrid.tsx` `Props` (lines ~376-380), change:
+
+```ts
+  onCellClick: (userId: number, date: string, cells: ResolvedCell[]) => void;
+```
+
+- [ ] **Step 4: Add the `.plan-cell-record` style + tighten chip block for stacking**
+
+In the `PlanGridRoot` styled block, add a rule (near the `.plan-chip-block` rules, ~line 294):
+
+```ts
+  "& .plan-cell-record": {
+    display: "block",
+    width: "100%",
+    minWidth: 0,
+  },
+  "& .plan-cell-record + .plan-cell-record": {
+    marginTop: 5,
+    paddingTop: 5,
+    borderTop: `1px dashed ${theme.vars!.palette.divider}`,
+  },
+```
+
+- [ ] **Step 5: Temporarily adapt `PlanWork.openCell` signature (still opens primary)**
+
+`onCellClick` now passes `ResolvedCell[]`. In `src/admin/pages/PlanWork.tsx`, change `openCell` to accept the array but keep current behaviour by using its first element (Task 4 replaces this with the day panel). Change the signature line (~204) and its first line:
+
+```ts
+  const openCell = useCallback(
+    (userId: number, date: string, _cells: ResolvedCell[]) => {
+      const cell = getCell(grid, userId, date);
+      void _cells;
+```
+
+Add `ResolvedCell` to the import from `../lib/queries/plan` at the top of PlanWork.tsx.
+
+- [ ] **Step 6: Gate + Chrome check**
+
+```bash
+npx tsc -b --noEmit
+npm run build
+```
+
+Then in Chrome (dev server already running — do not start it): open `/plan-work`, create two entries on the same day for one person, confirm both render stacked in the cell; confirm a single-record cell still shows its note; confirm light/dark both readable.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/admin/components/PlanRangeChips.tsx src/admin/components/PlanGrid.tsx src/admin/pages/PlanWork.tsx
+git commit -m "feat(plan): grid renders up to 3 stacked records per cell"
+```
+
+---
+
+## Task 4: Cell editor — the day panel
+
+**Files:**
+
+- Modify: `src/admin/components/PlanCellModal.tsx`
+- Modify: `src/admin/hooks/usePlanWork.ts` (add `day` to `ModalMode`)
+- Modify: `src/admin/pages/PlanWork.tsx`
+
+When a cell has ≥1 record, clicking it opens a panel listing the day's records (edit/delete each) plus "+ Přidat záznam" (disabled at 3). Empty cells still open the create form directly. Editing a record reuses the existing edit flows.
+
+- [ ] **Step 1: Add `day` to the hook's `ModalMode`**
+
+In `src/admin/hooks/usePlanWork.ts`, add to the `ModalMode` union (line ~12):
+
+```ts
+  | { kind: "day"; userId: number; date: string }
+```
+
+- [ ] **Step 2: Add a `day` variant + `DayPanel` to `PlanCellModal`**
+
+In `src/admin/components/PlanCellModal.tsx`:
+
+(a) Add to the `PlanCellModalMode` union (after `view`, ~line 67):
+
+```ts
+  | { kind: "day"; userId: number; date: string; cells: ResolvedCell[] };
+```
+
+(b) Add callbacks to `Props` (after `onSwitchToEditRange`, ~line 86):
+
+```ts
+  /** Open the create form for a brand-new record on (userId, date). */
+  onAddRecord: (userId: number, date: string) => void;
+  /** Open the right editor for one of the day's existing records. */
+  onEditRecord: (cell: ResolvedCell, userId: number, date: string) => void;
+```
+
+(c) In the top-level `PlanCellModal` switch (lines ~109-116), add before the final `return <EditForm/>`:
+
+```ts
+  if (mode.kind === "day") return <DayPanel {...props} mode={mode} />;
+```
+
+(d) Add the `DayPanel` component (and a small `EditIcon`) at the end of the file:
+
+```tsx
+const EditIcon = (
+  <svg
+    width="14"
+    height="14"
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth="2"
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden
+  >
+    <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
+    <path d="M18.5 2.5a2.12 2.12 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" />
+  </svg>
+);
+
+function DayPanel(
+  props: Props & { mode: Extract<PlanCellModalMode, { kind: "day" }> },
+) {
+  const { mode, onClose, onAddRecord, onEditRecord, categories } = props;
+  const catMap = Object.fromEntries(categories.map((x) => [x.key, x]));
+  const atCap = mode.cells.length >= 3;
+  const free = 3 - mode.cells.length;
+  return (
+    <Modal
+      isOpen
+      title={`Plán — ${formatDate(mode.date)}`}
+      onClose={onClose}
+      onSubmit={onClose}
+      submitText="Zavřít"
+      hideCancel
+    >
+      <Box sx={{ display: "flex", flexDirection: "column", gap: 1.25, mb: 2 }}>
+        {mode.cells.map((c, i) => {
+          const color =
+            catMap[c.category]?.color || "var(--mui-palette-divider)";
+          const projectLabel = cellProjectLabel(c);
+          return (
+            <Card key={c.entryId ?? `o${c.overrideId}` ?? i} variant="outlined">
+              <Box sx={{ display: "flex", alignItems: "center", gap: 1.5 }}>
+                <Box
+                  sx={{
+                    width: 4,
+                    alignSelf: "stretch",
+                    minHeight: 28,
+                    borderRadius: 2,
+                    bgcolor: color,
+                  }}
+                />
+                <Box sx={{ flex: 1, minWidth: 0 }}>
+                  <Typography sx={{ fontWeight: 600, fontSize: "0.85rem" }}>
+                    {planCategoryLabel(c.category, catMap)}
+                    {projectLabel ? ` · ${projectLabel}` : ""}
+                  </Typography>
+                  {c.note && (
+                    <Typography variant="body2" color="text.secondary" noWrap>
+                      {c.note}
+                    </Typography>
+                  )}
+                </Box>
+                <Button
+                  variant="outlined"
+                  color="inherit"
+                  startIcon={EditIcon}
+                  onClick={() => onEditRecord(c, mode.userId, mode.date)}
+                >
+                  Upravit
+                </Button>
+              </Box>
+            </Card>
+          );
+        })}
+      </Box>
+      <Box sx={{ display: "flex", alignItems: "center", gap: 1.5 }}>
+        <Button
+          variant="contained"
+          color="primary"
+          disabled={atCap}
+          onClick={() => onAddRecord(mode.userId, mode.date)}
+        >
+          + Přidat záznam
+        </Button>
+        <Typography variant="caption" color="text.secondary">
+          {atCap ? "Maximum 3 záznamy na den" : `${free} volné místo`}
+        </Typography>
+      </Box>
+    </Modal>
+  );
+}
+```
+
+(Per-record delete is reached through "Upravit" → the existing edit form's "Smazat" button, so the panel stays simple. The `cellProjectLabel` import already exists in this file.)
+
+- [ ] **Step 3: Wire the panel in `PlanWork`**
+
+In `src/admin/pages/PlanWork.tsx`:
+
+(a) Replace `openCell` so an occupied editable cell opens the `day` panel (empty → create, past → view as today):
+
+```ts
+const openCell = useCallback(
+  (userId: number, date: string, cells: ResolvedCell[]) => {
+    const primary = cells[0] ?? null;
+    if (isPastDate(date, todayIsoLocal())) {
+      if (!primary) return;
+      setModalCell(primary);
+      setHookModal({ kind: "view", userId, date });
+      return;
+    }
+    if (cells.length === 0) {
+      if (canEdit) openCreate(userId, date);
+      return;
+    }
+    if (!canEdit) {
+      setModalCell(primary);
+      setHookModal({ kind: "view", userId, date });
+      return;
+    }
+    setHookModal({ kind: "day", userId, date });
+  },
+  [canEdit, openCreate, setHookModal],
+);
+```
+
+(b) Add `onEditRecord` — open the correct editor for one record (this is the per-record version of the old `openCell` branch logic):
+
+```ts
+const editRecord = useCallback(
+  (cell: ReturnType<typeof getCell>, userId: number, date: string) => {
+    if (!cell) return;
+    setModalCell(cell);
+    if (cell.source === "entry" && cell.entryId !== null) {
+      if (cell.rangeFrom && cell.rangeTo && cell.rangeFrom !== cell.rangeTo) {
+        setHookModal({
+          kind: "day-in-range",
+          entryId: cell.entryId,
+          userId,
+          date,
+        });
+      } else {
+        setHookModal({
+          kind: "edit-range",
+          entryId: cell.entryId,
+          userId,
+          date,
+        });
+      }
+      return;
+    }
+    if (cell.source === "override" && cell.overrideId !== null) {
+      setHookModal({
+        kind: "edit-override",
+        overrideId: cell.overrideId,
+        userId,
+        date,
+      });
+    }
+  },
+  [setHookModal],
+);
+```
+
+(c) Build the `day` modalMode in the `modalMode` memo (add a branch before the final `return { kind: "closed" }`):
+
+```ts
+if (hookModal.kind === "day") {
+  return {
+    kind: "day",
+    userId: hookModal.userId,
+    date: hookModal.date,
+    cells: getCells(grid, hookModal.userId, hookModal.date),
+  };
+}
+```
+
+Import `getCells` alongside `getCell` from `../hooks/usePlanWork`.
+
+(d) Pass the two new props to `<PlanCellModal>`:
+
+```tsx
+onAddRecord = { openCreate };
+onEditRecord = { editRecord };
+```
+
+(e) Update the `modalKey` memo so the `day` mode re-keys cleanly — it already uses `m.userId`/`m.date`, which the `day` variant has, so no change is needed. Verify `HookModalMode` includes `day` (Step 1 added it).
+
+- [ ] **Step 4: Gate + Chrome check**
+
+```bash
+npx tsc -b --noEmit
+npm run build
+```
+
+In Chrome on `/plan-work`: click an occupied cell → day panel lists the records; "+ Přidat záznam" creates a 2nd/3rd record; at 3 it's disabled with "Maximum 3 záznamy na den"; "Upravit" on a range record still shows the range-vs-this-day chooser; delete via the edit form removes one record; empty cell still opens create directly; past day opens view.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/admin/components/PlanCellModal.tsx src/admin/hooks/usePlanWork.ts src/admin/pages/PlanWork.tsx
+git commit -m "feat(plan): day panel — list/add/edit up to 3 records per cell"
+```
+
+---
+
+## Task 5: Release v2.0.5
+
+**Files:**
+
+- Modify: `package.json`
+
+- [ ] **Step 1: Bump version**
+
+Set `"version": "2.0.5"` in `package.json`.
+
+- [ ] **Step 2: Full gate**
+
+```bash
+npx tsc -b --noEmit
+npx vitest run
+npm run build
+```
+
+Expected: tsc exit 0, vitest all pass, build success.
+
+- [ ] **Step 3: Commit + tag**
+
+```bash
+git add package.json
+git commit -m "chore(release): v2.0.5 — multi-record plan cells"
+git tag -a v2.0.5 -m "v2.0.5 — multi-record plan cells (max 3 per cell)"
+```
+
+- [ ] **Step 4: Push to Gitea (with user confirmation)**
+
+```bash
+git push origin master
+git push origin v2.0.5
+```
+
+- [ ] **Step 5: Build tarball + deploy to production (REQUIRES explicit user confirmation — do not auto-deploy)**
+
+```bash
+tar -czf app-ts-2.0.5.tar.gz dist dist-client prisma package.json package-lock.json scripts
+scp app-ts-2.0.5.tar.gz boha_admin@192.168.50.100:/tmp/
+ssh boha_admin@192.168.50.100 'set -e; cd /var/www/app-ts && rm -rf dist dist-client prisma scripts package.json package-lock.json && tar -xzf /tmp/app-ts-2.0.5.tar.gz && npm install --omit=dev && npx prisma migrate deploy && pm2 restart app-ts --update-env'
+```
+
+No migration ships in this release, so `prisma migrate deploy` reports "No pending migrations".
+
+- [ ] **Step 6: Health check**
+
+```bash
+ssh boha_admin@192.168.50.100 'curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:3001/; curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:3001/api/admin/session'
+```
+
+Expected: `200` then `401`. Confirm pm2 shows `app-ts` v2.0.5 online.
+
+---
+
+## Notes for the implementer
+
+- **Past-date rule** is unchanged and still enforced server-side; the day panel and create flow inherit it.
+- **Optimistic updates** are approximate by design — the `invalidate()` + refetch after each mutation is the source of truth and corrects the cell arrays (including the override-hides-entries layering) within ~200ms. Don't try to make the optimistic patch reproduce the exact layering.
+- **Do not start the dev server** — the user runs it. Use the running instance for Chrome checks.
+- **Do not deploy to production without explicit confirmation** (Task 5, Steps 5–6).