release v1.7.1: native template autocomplete, durable indicator migration

Template file fields used an unstyled <datalist>, not Obsidian's native suggest popup. Replace it with TemplateFileSuggest, an AbstractInputSuggest<TFile> matching Templater's own FileSuggest/FolderSuggest pattern exactly. Requires Obsidian >=1.4.10; minAppVersion corrected.

The coloured-indicator default never reached existing installs: every install that loaded before that default changed had already persisted the prior default (indicatorMode: 'any') to data.json as if it were a deliberate choice, and Object.assign-based settings merging always prefers a value already on disk over a new code default. Hand-editing data.json directly does not fix this durably either -- Obsidian holds settings in memory while a vault is open and overwrites external edits on its own save cycle.

Add a one-time, code-level migration: on load, an install with a persisted indicatorMode of 'any' and no indicatorModeMigrated flag is promoted to 'systems' and the flag is persisted immediately, so it survives even a session with no further settings changes. Any indicatorMode chosen after the flag exists, any (deliberately) included, is never touched again.

DOCUMENTATION.md

@@ -9,12 +9,13 @@
 ```
 src/
 ├── main.ts                  Plugin entry — lifecycle, commands, events, data persistence
-├── settings.ts              Interface definitions + DEFAULT_SETTINGS constant
-├── settings-tab.ts          PluginSettingTab UI — tabs: calendar, periodic, recent, display, about
+├── settings.ts              Interface definitions + DEFAULT_SETTINGS / DEFAULT_DATE_SYSTEM constants
+├── settings-tab.ts          PluginSettingTab UI — calendar, periodic, date systems, recent, display, about
 ├── models/
 │   └── bookmark.ts          BookmarkItem + WaypointData interfaces
 ├── utils/
 │   ├── date-utils.ts        Moment.js helpers: period formatting, month grid, navigation
+│   ├── date-systems.ts      Pure date-system filename helpers (no `obsidian` import, unit-testable)
 │   └── path-utils.ts        Pure path helper: rename remapping (no `obsidian` import, unit-testable)
 └── views/
     └── waypoint-view.ts     ItemView subclass — full sidebar rendering + interaction
@@ -30,7 +31,7 @@ src/
 
 ### `onload()`
 
-1. **Load data** — `loadSettings()` then `loadWaypointData()`, both merge saved partials over defaults via `Object.assign({}, DEFAULT, partial)`.
+1. **Load data** — reads `data.json` exactly once, then `applySettings(saved)` and `applyWaypointData(saved)` merge its partial data over defaults.
 2. **Register view** — `WAYPOINT_VIEW_TYPE = "waypoint-view"` maps to `WaypointView` factory `(leaf) => new WaypointView(leaf, this)`.
 3. **Settings tab** — `WaypointSettingTab` receives the live `settings` object + `() => this.redrawAll()` callback for live preview.
 4. **Register commands** (see Commands section below).
@@ -50,12 +51,13 @@ Detaches all leaves of `WAYPOINT_VIEW_TYPE`.
 
 ```typescript
 interface WaypointSettings {
-  calendar: CalendarSettings;         // firstDayOfWeek (0=Sun,1=Mon), showNoteIndicators
+  calendar: CalendarSettings;         // week start, indicator visibility/style, daily indicator colour
   daily: PeriodNoteSettings;
   weekly: PeriodNoteSettings;
   monthly: PeriodNoteSettings;
   quarterly: PeriodNoteSettings;
   yearly: PeriodNoteSettings;
+  dateSystems: DateSystemSettings[]; // day-scoped systems beyond the daily note, in menu order
   recentFiles: RecentFilesSettings;  // maxItems, updateOn, omittedPaths[], omittedTags[], filterTags[]
   display: DisplaySettings;           // px sizing for bookmark rows, fonts, icons, calendar cells
 }
@@ -69,7 +71,9 @@ interface PeriodNoteSettings {
 
 interface CalendarSettings {
   firstDayOfWeek: number;                   // 0 = Sunday, 1 = Monday
-  showNoteIndicators: boolean; // dot on days with existing .md files
+  showNoteIndicators: boolean;              // show or hide all calendar markers
+  indicatorMode: 'any' | 'systems';         // defaults to systems; one neutral dot or one per date system
+  dailyIndicatorColor: string;              // daily's colour in systems mode
 }
 
 interface RecentFilesSettings {
@@ -90,6 +94,8 @@ interface DisplaySettings {
 }
 ```
 
+`dateSystems` holds the user's configured date systems in menu order — see the Date Systems section for the `DateSystemSettings` shape and the two systems shipped by default.
+
 ### BookmarkItem (recursive tree)
 
 ```typescript
@@ -147,6 +153,116 @@ These call `navigatePeriodNote(direction)` which:
 
 ---
 
+## Date Systems
+
+A **date system** is a folder of notes whose filenames begin with a date. Daily notes, a journal and meeting notes are all the same shape, so they share one settings model, one discovery pass and one creation path.
+
+### `DateSystemSettings`
+
+interface DateSystemSettings {
+  id: string;             // stable across edits + reordering, so settings rows can key on it
+  name: string;           // menu label, e.g. "Journal"
+  folder: string;         // e.g. "periodic/journal"
+  nameFormat: string;     // moment format string; may contain "{title}"
+  templateFile: string;   // may omit the .md extension
+  typeProperty: string;   // fallback frontmatter `type:` value
+  icon: string;           // Lucide icon name for the menu item
+  indicatorColor: string; // calendar dot colour in systems mode
+}
+```
+
+Configured systems live in `settings.dateSystems`, where array order is menu order. `DEFAULT_DATE_SYSTEM` (in `settings.ts`, typed `Omit<DateSystemSettings, 'id'>`) supplies the field defaults for a newly added row **and** the merge base for saved ones, so a system persisted before a field existed still loads with that field defined. `DEFAULT_SETTINGS.dateSystems` ships two:
+
+| `id` | `name` | Folder | `nameFormat` | Indicator colour | Notes per date |
+|---|---|---|---|---|---|
+| `journal` | Journal | `periodic/journal` | `YYYY-MM-DD - [Journal]` | green (`#22c55e`) | one |
+| `meetings` | Meeting | `periodic/meetings` | `YYYY-MM-DD - {title}` | violet (`#a855f7`) | many |
+
+The default calendar mode is `systems`, while `any` preserves the older one-neutral-dot behaviour. Existing installs that silently persisted the pre-`systems` default of `any` are promoted to `systems` exactly once, on load, via a `data.json`-level `indicatorModeMigrated` flag; a value chosen after that flag is set (including `any`) is never touched again. Template file fields in both Periodic Notes and Date systems use `TemplateFileSuggest`, an `AbstractInputSuggest<TFile>` (the same base class Templater's own template pickers use — Obsidian's native fuzzy-suggest popup, not an unstyled `<datalist>`), searching every Markdown path in the vault. `AbstractInputSuggest` requires Obsidian ≥1.4.10, hence `manifest.json`'s `minAppVersion`.
+
+### Templater folder triggers
+
+Waypoint deliberately does not evaluate Templater syntax. For an interactive Templater template, configure Templater's **Trigger Templater on new file creation** mode for the relevant folder, then leave that date system's `templateFile` blank in Waypoint. Waypoint creates a safe fallback note from `typeProperty` and the selected `YYYY-MM-DD` date; Templater's folder trigger owns the rendered content, prompts, scripts, and cursor placement.
+
+The target filename is the contract between them. A calendar-created journal note is already named `YYYY-MM-DD - Journal`; a meeting is already `YYYY-MM-DD - {title}`. Templates must extract the date from `tp.file.title`, not `tp.date` or `tp.file.creation_date()`, because those refer to when Templater runs rather than the date selected in the calendar.
+
+The journal template may retain a manual fallback: only prompt for a date and rename when `tp.file.title` does **not** match the date-system filename. That preserves manual note creation without a prompt or rename race on calendar creation.
+
+### The `{title}` convention
+
+`nameFormat` is a moment format string, so literal text needs bracket escaping — `YYYY-MM-DD - [Journal]` — the same convention the periodic formats `GGGG-[W]WW` and `YYYY-[Q]Q` already use.
+
+When the format contains `{title}`, the system holds **many** notes per date: the text before the token is the date prefix used to discover them, and the token marks where a typed free-text title goes on creation. Without the token, a date maps to **exactly one** filename.
+
+**Why the token is split out before moment sees the string:** `t`, `i`, `l` and `e` are all live moment format tokens — `l` on its own expands to an entire localized date. Passing `{title}` through `date.format()` would expand those letters and destroy the placeholder, with no way to recover it afterwards. `splitNameFormat()` therefore cuts the format at the token *first*, and callers format `before` and `after` separately, then join the two results around the title. It is also why discovery matches on formatted affixes instead of on a regex derived from the raw format.
+
+### Helpers (`src/utils/date-systems.ts`)
+
+Imports nothing from `'obsidian'` — callers make every moment call and pass the resulting strings in, which keeps the module unit-testable in plain node (same rationale as `path-utils.ts`).
+
+| Export | Signature | Purpose |
+|---|---|---|
+| `TITLE_TOKEN` | `'{title}'` | The literal placeholder. |
+| `splitNameFormat(nameFormat)` | `string → NameFormatParts` | `{ before, after, hasTitle }` — the format cut around the token. |
+| `isInFolder(path, folder)` | `string, string → boolean` | Path sits in `folder` or any subfolder. An empty folder means the vault root, so everything matches. |
+| `matchesSystemName(basename, before, after, hasTitle)` | `string, string, string, boolean → boolean` | One-per-date: the basename must equal `before + after`. Many-per-date: prefix/suffix match, since the middle is free text. |
+| `titleFromBasename(basename, before, after)` | `string, string, string → string` | Strips the affixes to recover the menu label; falls back to the whole basename when they do not line up. |
+| `sanitizeTitle(title)` | `string → string` | Collapses filename-illegal and link-syntax characters (`\ / : * ? " < > \| # ^ [ ]`) to `-`, squeezes runs of whitespace, trims — so a typed "Meeting w/ Mark" still yields a creatable filename. |
+| `formatHasDateToken(nameFormat)` | `string → boolean` | Strips bracket-escaped literals out of `before`, then looks for any moment date token. Drives the settings warning. |
+`matchesSystemName` deliberately returns `false` for a many-per-date format whose `before` is empty (a format of just `{title}`): an empty date prefix would otherwise claim every file in the folder for every date. The settings tab flags formats with no date token, and `findDateSystemNotes()` excludes them from the menu; `openDateSystemNote()` also refuses them. An unfinished or invalid row therefore cannot create `.md` or a static filename.
+
+### Plugin API (`main.ts`)
+
+```typescript
+interface DateSystemNote {
+  file: TFile;
+  label: string; // free-text title for many-per-date systems, else the system name
+}
+
+interface DateSystemNotes {
+  system: DateSystemSettings;
+  notes: DateSystemNote[];
+  multiple: boolean; // nameFormat carries {title}
+}
+
+interface DateSystemIndicator {
+  id: string;
+  name: string;
+  color: string;
+}
+
+dateSystems(): DateSystemSettings[]
+findDateSystemNotes(date: moment.Moment): DateSystemNotes[]
+getDateSystemIndicators(dates: moment.Moment[]): Map<string, DateSystemIndicator[]>
+openDateSystemNote(
+  system: DateSystemSettings,
+  date: moment.Moment,
+  opts?: { title?: string; leaf?: WorkspaceLeaf },
+): Promise<void>
+```
+
+**`getDateSystemIndicators(dates)`** — returns one `{ id, name, color }` marker per configured system with one or more notes on a requested day. The calendar calls it once for the visible month only in `indicatorMode: 'systems'`. It makes one vault pass, caches the result by displayed dates and date-system settings, and invalidates it on markdown create/delete/rename or any Settings change. It does not run on ordinary markdown edits: content edits cannot change a filename-derived indicator.
+
+**`dateSystems()`** — every day-scoped system in menu order: the daily periodic note, synthesized into a `DateSystemSettings` from `settings.daily`, followed by `settings.dateSystems`. The daily note is therefore not a special case in any consumer.
+
+**`findDateSystemNotes(date)`** — **one** vault scan per call, not one per system. It formats each usable system's `before`/`after` affixes for `date` once, then walks the markdown file list a single time, bucketing each file into the system that claims it (`isInFolder` + `matchesSystemName`). Systems whose formats have no date token are omitted rather than offering an unsafe create action. It returns the remaining `DateSystemNotes` in `dateSystems()` order, each bucket sorted by basename. The calendar's day context menu is built from exactly one of these calls per right-click.
+
+**`openDateSystemNote(system, date, opts)`** — the single opener for every dated note:
+
+1. **Filename** — `splitNameFormat(system.nameFormat)`, format `before` and `after` against `date`, and for a many-per-date system join `sanitizeTitle(opts.title)` between them. Append `.md`; prepend `system.folder` when it is set.
+2. **Existing note** — a `vault.getFileByPath()` hit is opened as-is, never overwritten. A date that already has notes can still gain another in a many-per-date system, because the title makes the filename unique.
+3. **Missing note** — created via `createDatedNote`, then opened.
+4. **Leaf** — `opts.leaf` when supplied (middle-click and Ctrl/Cmd-click pass an explicit tab leaf), otherwise `workspace.getLeaf(false)`.
+
+### Note creation (`createDatedNote`)
+
+A single creation path shared by periodic notes and date systems; it replaced the period-only `createPeriodNote`.
+
+1. With a non-empty `system.templateFile`, reads it (appending `.md` when omitted) and creates the note with its raw contents. This is for plain, non-Templater templates.
+2. With no template, the note is created with minimal frontmatter instead: `type: {system.typeProperty}` + `date: YYYY-MM-DD`. Use this mode with a Templater folder trigger, which replaces that fallback content with its rendered template.
+
+---
+
 ## Period Note Creation (`openPeriodNote`)
 
 ```typescript
@@ -157,16 +273,9 @@ openPeriodNote(
 ): Promise<void>
 ```
 
-Single unified opener — there is no separate `openPeriodNoteInLeaf`. For a given period + moment date:
+Single unified opener — there is no separate `openPeriodNoteInLeaf`, and since the date-systems refactor there is no separate creation path either. `openPeriodNote` synthesizes the period's `PeriodNoteSettings` into a `DateSystemSettings` (`folder`, `nameFormat`, `templateFile` and `typeProperty` carry over verbatim; a period format never contains `{title}`, so a period maps to exactly one filename) and delegates to `openDateSystemNote(system, date, { leaf })`.
 
-1. **Build filename:** `date.format(periodSettings.nameFormat) + ".md"`.
-2. **Build full path:** If `periodSettings.folder` is set, prepend it; otherwise root.
-3. **Check existence:** `vault.getFileByPath(fullPath)`.
-4. **If not found, create:**
-   - Try to read template at `periodSettings.templateFile + ".md"`.
-   - If template exists → `vault.create(fullPath, templateContent)`.
-   - If no template → `vault.create(fullPath, minimalFrontmatter)` where frontmatter is `type: {typeProperty}` + `date: YYYY-MM-DD`.
-5. **Open:** in `leaf` when one is supplied, otherwise in `workspace.getLeaf(false)`.
+Filename building, the existence check, template-or-frontmatter creation and leaf selection are therefore documented once, under Date Systems above.
 
 Middle-click handlers in the view pass an explicit tab leaf: `openPeriodNote(period, date, this.app.workspace.getLeaf('tab'))`.
 
@@ -202,7 +311,7 @@ Both update the markdown-basename set used for calendar note indicators, then tr
 recentFiles: { path: string; basename: string }[]
 ```
 
-Backed by `waypointData.recentFiles` in `data.json`, so the list survives vault reload. `loadWaypointData()` restores it and re-applies the current `maxItems` limit (in case the setting shrank since the last save).
+Backed by `waypointData.recentFiles` in `data.json`, so the list survives vault reload. `applyWaypointData(saved)` restores it and re-applies the current `maxItems` limit (in case the setting shrank since the last save).
 
 **Update flow:**
 1. `addToRecentFiles(file)` — omission check, then dedupes (removes existing entry), prepends to front, truncates to `maxItems`.
@@ -250,9 +359,16 @@ The last section (`waypoint-section:last-child`) gets `margin-top: auto`, pushin
 - **Breadcrumb:** Q-label, month name, year — each clickable to open that period note.
 - **Nav buttons:** ◀/▶ shift month ±1. "Today" resets to current month.
 - **Week number column:** Clicking a week number opens the weekly note for that week's Monday; middle-clicking opens it in a new tab.
-- **Day cells:** Click opens daily note, middle-click opens it in a new tab. `.other-month` dimmed. `.today` has accent border. `.has-note` gets a dot indicator, decided by the synchronous O(1) `plugin.hasNoteForDate(dateStr)` (a `Set` lookup — no per-cell vault scan).
+- **Day cells:** Left-click opens the daily note, middle-click opens it in a new tab, right-click opens the day context menu (below). `.other-month` is muted; `.today` has an inset accent ring; hover receives a quiet fill. With `indicatorMode: 'any'`, `.has-note` shows the existing single neutral dot through the O(1) `plugin.hasNoteForDate(dateStr)` lookup. With `indicatorMode: 'systems'`, the view calls `getDateSystemIndicators()` once for the month and renders one tooltip-labelled coloured dot per matching daily/journal/meeting/custom system.
 - **Grid generation:** `getMonthGrid(year, month, firstDayOfWeek)` in `date-utils.ts` produces up to 6 weeks, each with 7 `CalendarDay` objects containing `moment`, `dayOfMonth`, `isToday`, `isCurrentMonth`, `isoWeekNumber`.
 
+**Day context menu (right-click):** Built from a single `plugin.findDateSystemNotes(day.date)` call. The first entry is a non-clickable header showing the full date. Then, per system in `dateSystems()` order:
+
+- Each existing note, labelled with its `DateSystemNote.label` and the system's `icon`. Click opens it in the current leaf; Ctrl/Cmd-click opens it in a new tab.
+- A create entry (icon `plus`) labelled `New {lowercased system name} note`. Many-per-date systems always show one, with a trailing ellipsis because it first opens a `PromptModal` for the title (`New meeting note…`). A one-per-date system shows one without the ellipsis only while its note is missing (`New journal note`); once the note exists, the existing-note entry is all it gets.
+
+Every label is derived from `system.name`, so a renamed or newly added system needs no view changes. Left-click and middle-click on the cell are untouched.
+
 ### Recent Files Panel
 
 Renders `plugin.recentFiles` as Obsidian-native `nav-file` elements using the file explorer's CSS classes (`tree-item`, `nav-file-title`, `nav-file-title-content`).
@@ -292,7 +408,7 @@ Renders `plugin.recentFiles` as Obsidian-native `nav-file` elements using the fi
 
 **Context menu (right-click):**
 - File items: "Open in new tab"
-- File/Group items: "Rename" (opens `RenameModal`), "Change icon" (opens `IconSuggestModal`)
+- File/Group items: "Rename" (opens `PromptModal`), "Change icon" (opens `IconSuggestModal`)
 - "Move to group" submenu: Lists all available groups (excluding self + descendants) + "(Root)" for ungrouping
 - Group items: "Expand/Collapse", "Add bookmark here", "New sub-group"
 - All items: "Insert separator above/below", "Insert spacer above/below", "Remove"
@@ -302,13 +418,13 @@ Renders `plugin.recentFiles` as Obsidian-native `nav-file` elements using the fi
 2. If targetGroupId: find group, set `item.indent = group.indent + 1`, push to group's children.
 3. If null (root): set `item.indent = 0`, push to `waypointData.bookmarks`.
 
-**Rename modal (`RenameModal`):** Simple Modal with text input + Cancel/Save buttons. Enter key submits.
+**Prompt modal (`PromptModal`):** Simple Modal with a text input plus Cancel and CTA buttons. Enter key submits. Constructed as `new PromptModal(app, options, onSubmit)`, where `options` is `{ title, placeholder?, initialValue?, cta? }` and `cta` (the submit button label) defaults to `Save`. Generalized from the old rename-only `RenameModal` so the calendar's day context menu can reuse it to prompt for a note title.
 
 **Icon picker (`IconSuggestModal`):** Modal with:
 - Live preview of selected icon.
 - Search input with 60ms debounce.
 - Grid of matching icons (max 80 shown), loaded from `https://cdn.jsdelivr.net/npm/lucide-static@0.517.0/tags.json` with fallback to `https://lucide.dev/api/tags` and a hardcoded `FALLBACK_ICONS` object (~300 icons). The fetch result is cached for the session, so at most one network round-trip happens no matter how often the picker is opened.
-- Click to select, "No icon" link to clear, Save/Cancel buttons.
+- Click to select, **No icon** button to clear, Save/Cancel buttons.
 
 ---
 
@@ -317,18 +433,19 @@ Renders `plugin.recentFiles` as Obsidian-native `nav-file` elements using the fi
 All classes prefixed with `waypoint-`. Uses Obsidian CSS variables throughout:
 
 - `--font-ui-small`, `--font-ui-medium`, `--font-semibold`, `--font-medium`, `--font-light`
-- `--text-muted`, `--text-faint`, `--text-accent`, `--text-on-accent`
-- `--background-modifier-border`, `--background-modifier-active-hover`, `--background-primary`, `--background-secondary`
+- `--text-muted`, `--text-faint`, `--text-accent`, `--text-on-accent`, `--text-error`
+- `--background-modifier-border`, `--background-modifier-active-hover`, `--background-modifier-hover`, `--background-primary`, `--background-primary-alt`, `--background-secondary`
 - `--interactive-accent`
-- `--cursor` (for custom cursor support)
+- `--cursor-link` (pointer cursor, with a `pointer` fallback)
 
 Key layout:
 - `.waypoint-view` — flex column, `overflow-y: auto`, 8px padding.
 - `.waypoint-section` — `flex-shrink: 0`, 16px bottom margin. Last section gets `margin-top: auto` (pins calendar to bottom).
-- `.waypoint-section-header` — uppercase, muted, with bottom border.
-- Calendar table — `table-layout: fixed`, `border-collapse: collapse`.
-- `.waypoint-day.today` — accent color text + 1px accent border.
-- `.waypoint-day.has-note::after` — 4px dot indicator.
+- `.waypoint-calendar` — padded, bordered surface with separated day cells for clear scan lines.
+- Calendar table — `table-layout: fixed`, `border-collapse: separate`, 2px horizontal / 3px vertical cell spacing.
+- `.waypoint-day.today` — accent text with an inset accent ring, avoiding layout shifts.
+- `.waypoint-day.has-note::after` — neutral single-dot indicator.
+- `.waypoint-day-indicators` / `.waypoint-day-indicator` — compact ordered dot row; `--waypoint-indicator-color` carries each configured system colour.
 - `.waypoint-bm-chevron` — `rotate(-90deg)` on collapsed groups.
 - `.waypoint-bm-drop-line` / `.waypoint-bm-drop-below` — 3px accent border for drag indicators.
 
@@ -372,7 +489,7 @@ Settings and waypoint data share a single `data.json` via Obsidian's `Plugin.loa
 }
 ```
 
-Both `loadSettings()` and `loadWaypointData()` read from the same file, merging partials over defaults. `saveSettings()` and `saveWaypointData()` each re-read the full data, update their key, and write back — so they are serialized through a single-writer save queue: each call chains onto the previous one's promise instead of racing it. Recent-file writes additionally go through the 300ms debounce in `persistRecentFiles()`.
+`onload()` reads `data.json` once, then `applySettings(saved)` and `applyWaypointData(saved)` merge partial persisted values over defaults. `persistAll()` writes both in-memory keys through one promise chain; it never re-reads stale disk state. Recent-file writes additionally go through the 300ms debounce in `persistRecentFiles()`.
 
 ---
 

QA.md

@@ -70,6 +70,37 @@
 - [ ] Note indicator dots show on days with existing .md files
 - [ ] Today is highlighted with accent border
 
+## Calendar: System-coloured indicators
+
+- [ ] Calendar → Indicator style → **Single dot** keeps one neutral dot for an existing date-named note
+- [ ] Calendar → Indicator style → **Colour by note system** shows a blue dot for Daily, green for Journal, and violet for Meeting by default
+- [ ] A day holding multiple meeting notes still shows exactly one Meeting dot
+- [ ] A day holding Daily, Journal, and Meeting notes shows three compact dots in that order
+- [ ] Hover each coloured dot → its date-system name is identified by a tooltip
+- [ ] Change Daily/Journal/Meeting indicator colours in Settings → the visible calendar refreshes immediately
+- [ ] Add a custom date system with its own colour and a matching note → its dot appears in system order
+- [ ] Create, delete, or rename a date-system note → coloured dots refresh without changing months
+- [ ] An install that previously had **Single dot** as its silently-defaulted, never-touched setting shows **Colour by note system** after upgrading and reloading the plugin
+- [ ] After that one-time change, manually selecting **Single dot** and reloading again keeps **Single dot** — the migration never re-fires
+- [ ] Typing in any Template file field opens Obsidian's native fuzzy-suggest popup (matching the look of Templater's own template pickers), not a plain browser dropdown
+
+## Calendar: Date systems
+
+- [ ] Right-click a date with a daily note, journal note, and meeting note → full-date header, then all three systems appear in the menu
+- [ ] Right-click a date with no date-system notes → each single-note system offers a create action and the many-note system offers “New …”
+- [ ] Right-click a date with one meeting → the existing meeting and “New meeting note…” both appear
+- [ ] Create a second meeting for the same date → it is created with that date prefix and both meetings appear on the next right-click
+- [ ] Ctrl/Cmd-click an existing date-system menu entry → it opens in a new tab
+- [ ] Submit an empty title for a new many-note system → a clear notice appears and no malformed file is created
+- [ ] Add a date system in Settings → Date systems → it appears in the day menu
+- [ ] Reorder and delete date systems → the day menu immediately follows the configured order and removes the deleted system
+- [ ] Enter a non-empty name format with no date token → Settings shows the inline warning
+- [ ] Left-click a day still opens/creates its daily note; middle-click still opens it in a new tab
+
+- [ ] With Templater folder mappings for journal and meetings, create a date-system note → Templater expands `<% … %>` syntax rather than leaving it literal
+- [ ] Create a journal from the calendar → no duplicate date prompt and no rename; its frontmatter `date` equals the selected calendar day
+- [ ] Create a meeting from the calendar for a non-today date → its frontmatter `date` equals the selected calendar day
+
 ## Recent Files (Regression)
 
 - [ ] Opening a file adds it to recent files

README.md

@@ -4,7 +4,8 @@ Calendar, recent files, and custom bookmarks sidebar for Obsidian.
 
 ## Features
 
-- **Calendar panel** — month grid with clickable days, week numbers, period indicators (day/week/month/quarter/year)
+- **Calendar panel** — refined month grid; left-click a day opens its daily note, middle-click opens it in a tab, and right-click reveals every configured note system for that date
+- **Calendar indicators** — retain a single neutral note dot or show a coloured dot per daily, journal, meeting, or custom date system
 - **Recent files** — track recently opened/edited files
 - **Favorites** — custom bookmarks with groups, icons, and rename
 
@@ -19,6 +20,36 @@ Calendar, recent files, and custom bookmarks sidebar for Obsidian.
 | Go to yearly note | `Ctrl+Shift+Alt+Y` |
 | Next/Previous daily/weekly/monthly/quarterly/yearly note | — |
 
+## Date systems
+
+Right-click any calendar day to open its **date systems** menu. The daily note always appears first; left-click behaviour is unchanged. The included defaults match this vault's common layouts:
+
+| System | Folder | Name format | Behaviour |
+|---|---|---|---|
+| Journal | `periodic/journal` | `YYYY-MM-DD - [Journal]` | Opens or creates one journal note for the date |
+| Meeting | `periodic/meetings` | `YYYY-MM-DD - {title}` | Lists every meeting for the date and can create another |
+
+Configure systems in **Settings → Waypoint Sidebar → Date systems**. Each system has a folder, filename format, template, fallback frontmatter type, Lucide icon, and indicator colour. Template file fields autocomplete every Markdown path in the vault.
+
+`Name format` uses moment.js tokens. Bracket-escape literal text: `YYYY-MM-DD - [Journal]`. Add `{title}` when a date can have multiple notes; it is replaced with the title requested when creating a note. Without `{title}`, the system has exactly one note per date.
+
+Ctrl/Cmd-click a menu entry opens it in a new tab.
+
+### Calendar indicators
+
+Under **Settings → Waypoint Sidebar → Calendar**, choose either:
+
+- **Colour by note system** — the default; one compact coloured dot per configured date system that has a note on that day. Hover a dot to identify its system.
+- **Single dot** — a neutral marker for any note whose filename is exactly the date.
+
+Daily uses the Calendar tab’s colour picker. Journal, Meeting, and every custom system have their own **Indicator colour** picker under **Date systems**. The defaults are blue for Daily, green for Journal, and violet for Meeting.
+
+### Templater folder templates
+
+If a date system uses a Templater folder mapping, leave its Waypoint **Template file** field blank. Waypoint then creates a safe fallback note while Templater owns prompts, scripts, cursors, and rendered content.
+
+The selected calendar date is encoded in the filename. Templater templates should derive their `date` from `tp.file.title`, not from `tp.date` or `tp.file.creation_date()`. A journal template can retain a prompt-and-rename fallback for manual note creation, but it must skip that flow when the filename already follows `YYYY-MM-DD - Journal`.
+
 ## Installation
 
 ### Via BRAT

manifest.json

@@ -1,8 +1,8 @@
 {
 	"id": "waypoint-sidebar",
 	"name": "Waypoint Sidebar",
-	"version": "1.5.2",
-	"minAppVersion": "1.4.4",
+	"version": "1.7.1",
+	"minAppVersion": "1.4.10",
 	"description": "Calendar, recent files, and custom bookmarks sidebar.",
 	"author": "Olivier",
 	"isDesktopOnly": false

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "waypoint",
-	"version": "1.5.2",
+	"version": "1.7.1",
 	"description": "Calendar, recent files, and custom bookmarks sidebar.",
 	"main": "main.js",
 	"scripts": {

src/main.ts

@@ -10,14 +10,45 @@ import {
 	getAllTags,
 	moment,
 } from 'obsidian';
-import { WaypointSettings, DEFAULT_SETTINGS, PeriodNoteSettings } from 'src/settings';
+import { WaypointSettings, DEFAULT_SETTINGS, DateSystemSettings, DEFAULT_DATE_SYSTEM } from 'src/settings';
 import { WaypointSettingTab } from 'src/settings-tab';
 import { WaypointView, WAYPOINT_VIEW_TYPE } from 'src/views/waypoint-view';
 import { BookmarkItem, WaypointData } from 'src/models/bookmark';
 import { remapRenamedPath } from 'src/utils/path-utils';
+import {
+	splitNameFormat,
+	isInFolder,
+	matchesSystemName,
+	titleFromBasename,
+	sanitizeTitle,
+	formatHasDateToken,
+} from 'src/utils/date-systems';
 
 export type PeriodKey = 'day' | 'week' | 'month' | 'quarter' | 'year';
 
+/** One existing note of a date system, with the label the menu should show. */
+export interface DateSystemNote {
+	file: TFile;
+	/** Free-text title for many-per-date systems, else the system name. */
+	label: string;
+}
+
+/** A day-scoped system and the notes it already holds for one date. */
+export interface DateSystemNotes {
+	system: DateSystemSettings;
+	/** Sorted by basename. Empty when the date has no note in this system. */
+	notes: DateSystemNote[];
+	/** True when nameFormat carries {title}, i.e. many notes per date. */
+	multiple: boolean;
+}
+
+/** One coloured calendar marker for a date system that has a note on a day. */
+export interface DateSystemIndicator {
+	id: string;
+	name: string;
+	color: string;
+}
+
 export default class WaypointPlugin extends Plugin {
 	public settings: WaypointSettings;
 	public waypointData: WaypointData;
@@ -27,14 +58,29 @@ export default class WaypointPlugin extends Plugin {
 	private savePromise: Promise<void> = Promise.resolve();
 	/** Basenames of every markdown file in the vault, for O(1) calendar lookups. */
 	private markdownBasenames: Set<string> = new Set();
+	/** Results for the displayed month; invalidated by markdown-file changes. */
+	private dateSystemIndicators: Map<string, DateSystemIndicator[]> | null = null;
+	private dateSystemIndicatorKey = '';
+	/**
+	 * True once `data.json` carries the post-migration schema. Set on every
+	 * load and included in every save, so a single migration run is durable
+	 * even if this session never triggers another settings write.
+	 */
+	private indicatorModeMigrated = false;
 
 	async onload(): Promise<void> {
 		console.debug('Waypoint: loading plugin v' + this.manifest.version);
 
 		// Load persisted data — data.json is read exactly once here.
 		const saved = await this.loadData() as Record<string, unknown> | null;
-		this.applySettings(saved);
+		const migrated = this.applySettings(saved);
 		this.applyWaypointData(saved);
+		if (migrated) {
+			// Persist immediately: an install that only ever reads data.json
+			// (never changes a setting or bookmark this session) must still
+			// keep the migrated value instead of re-migrating every load.
+			void this.persistAll();
+		}
 
 		// Register the sidebar view
 		this.registerView(
@@ -49,6 +95,7 @@ export default class WaypointPlugin extends Plugin {
 			this.settings,
 			() => {
 				this.enforceRecentFilesLimit();
+				this.invalidateDateSystemIndicators();
 				this.redrawAll();
 			},
 		));
@@ -210,9 +257,11 @@ export default class WaypointPlugin extends Plugin {
 	/**
 	 * Merge persisted settings over the defaults. Nested objects are merged
 	 * individually so existing configs keep their values while picking up
-	 * fields added in newer versions.
+	 * fields added in newer versions. Returns true the one time a one-off
+	 * migration (see `indicatorModeMigrated` below) actually changes a value,
+	 * so the caller can persist that change immediately.
 	 */
-	private applySettings(saved: Record<string, unknown> | null): void {
+	private applySettings(saved: Record<string, unknown> | null): boolean {
 		const s = (saved?.settings || {}) as Partial<WaypointSettings>;
 		this.settings = Object.assign({}, DEFAULT_SETTINGS, s);
 		this.settings.recentFiles = Object.assign({}, DEFAULT_SETTINGS.recentFiles, s.recentFiles || {});
@@ -221,6 +270,33 @@ export default class WaypointPlugin extends Plugin {
 		for (const key of PERIOD_SETTING_KEYS) {
 			this.settings[key] = Object.assign({}, DEFAULT_SETTINGS[key], s[key] || {});
 		}
+		// Cloned, not Object.assign'd in: the defaults array would otherwise be
+		// aliased into the live settings and the settings UI would edit
+		// DEFAULT_DATE_SYSTEM so older configs pick up fields added since. Known
+		// built-ins use their own defaults too, preserving Journal/Meeting colours
+		// when this field is first introduced.
+		this.settings.dateSystems = Array.isArray(s.dateSystems)
+			? s.dateSystems.map(sys => {
+				const builtIn = DEFAULT_SETTINGS.dateSystems.find(defaultSystem => defaultSystem.id === sys.id);
+				return Object.assign({}, builtIn || DEFAULT_DATE_SYSTEM, sys);
+			})
+			: DEFAULT_SETTINGS.dateSystems.map(sys => Object.assign({}, sys));
+
+		// `indicatorMode` shipped with a default of 'any' before per-system
+		// colours existed, so every install that loaded before that default
+		// changed silently persisted 'any' to disk as if it were a deliberate
+		// choice — changing DEFAULT_SETTINGS alone can never reach an install
+		// that already has an explicit value on disk. Promote that one-time
+		// default to the current default exactly once; any choice made after
+		// this flag is set is real and must never be touched again.
+		const alreadyMigrated = saved?.indicatorModeMigrated === true;
+		let didMigrateValue = false;
+		if (!alreadyMigrated && s.calendar?.indicatorMode === 'any') {
+			this.settings.calendar.indicatorMode = 'systems';
+			didMigrateValue = true;
+		}
+		this.indicatorModeMigrated = true;
+		return didMigrateValue;
 	}
 
 	private applyWaypointData(saved: Record<string, unknown> | null): void {
@@ -255,6 +331,7 @@ export default class WaypointPlugin extends Plugin {
 			return this.saveData({
 				settings: this.settings,
 				waypointData: this.waypointData,
+				indicatorModeMigrated: this.indicatorModeMigrated,
 			});
 		});
 		// Keep the queue usable after a failed write without leaving an
@@ -361,6 +438,7 @@ export default class WaypointPlugin extends Plugin {
 	 * inside a renamed folder.
 	 */
 	private onRename(file: TAbstractFile, oldPath: string): void {
+		this.invalidateDateSystemIndicators();
 		const indexChanged = this.syncIndexForRename(file, oldPath);
 		let dataChanged = false;
 
@@ -396,6 +474,7 @@ export default class WaypointPlugin extends Plugin {
 	private onVaultCreate(file: TAbstractFile): void {
 		if (file instanceof TFile && file.extension === 'md') {
 			this.markdownBasenames.add(file.basename);
+			this.invalidateDateSystemIndicators();
 		}
 		this.broadcastRedraw();
 	}
@@ -403,6 +482,7 @@ export default class WaypointPlugin extends Plugin {
 	private onVaultDelete(file: TAbstractFile): void {
 		if (file instanceof TFile && file.extension === 'md') {
 			this.removeFromMarkdownIndex(file.basename, file.path);
+			this.invalidateDateSystemIndicators();
 		}
 		this.broadcastRedraw();
 	}
@@ -416,6 +496,12 @@ export default class WaypointPlugin extends Plugin {
 		}
 	}
 
+	/** Forget a month result when markdown paths or date-system settings change. */
+	private invalidateDateSystemIndicators(): void {
+		this.dateSystemIndicators = null;
+		this.dateSystemIndicatorKey = '';
+	}
+
 	/**
 	 * Drop a basename from the index, unless another markdown file still
 	 * carries it. `path` is excluded from that check because the vault may not
@@ -510,44 +596,212 @@ export default class WaypointPlugin extends Plugin {
 		}
 	}
 
-	// ── Period note creation/opening ──
+	// ── Date systems: discovery, creation, opening ──
+
+	/** Periodic notes are date systems with a fixed one-note-per-period format. */
+	private periodAsDateSystem(period: PeriodKey): DateSystemSettings {
+		const config = PERIOD_CONFIGS[period];
+		const periodSettings = this.settings[config.key];
+		return {
+			id: config.key,
+			name: config.label,
+			folder: periodSettings.folder,
+			nameFormat: periodSettings.nameFormat,
+			templateFile: periodSettings.templateFile,
+			typeProperty: periodSettings.typeProperty,
+			icon: 'calendar',
+			indicatorColor: this.settings.calendar.dailyIndicatorColor,
+		};
+	}
+
+	/** All day-scoped systems: the daily periodic note first, then settings.dateSystems. */
+	dateSystems(): DateSystemSettings[] {
+		return [this.periodAsDateSystem('day'), ...this.settings.dateSystems];
+	}
+
+	/**
+	 * Bucket the notes every day-scoped system already holds for `date`.
+	 *
+	 * One vault scan serves all systems at once. That is affordable because
+	 * this runs once per right-click, not once per calendar cell, and it keeps
+	 * arbitrary user-defined name formats out of the incremental index.
+	 */
+	findDateSystemNotes(date: moment.Moment): DateSystemNotes[] {
+		const buckets = this.dateSystems().map(system => {
+			const parts = splitNameFormat(system.nameFormat);
+			return {
+				result: { system, notes: [] as DateSystemNote[], multiple: parts.hasTitle },
+				// Each half is formatted on its own: the raw format may still
+				// hold {title}, whose letters are live moment tokens.
+				before: formatDatePart(date, parts.before),
+				after: formatDatePart(date, parts.after),
+				hasTitle: parts.hasTitle,
+				// Empty/date-less formats have no date-specific filename. They stay
+				// editable in Settings but must not contribute a menu action.
+				skip: !formatHasDateToken(system.nameFormat),
+			};
+		});
+
+		for (const file of this.app.vault.getMarkdownFiles()) {
+			for (const bucket of buckets) {
+				if (bucket.skip) continue;
+				const system = bucket.result.system;
+				if (!isInFolder(file.path, system.folder)) continue;
+				if (!matchesSystemName(file.basename, bucket.before, bucket.after, bucket.hasTitle)) continue;
+				bucket.result.notes.push({
+					file,
+					label: bucket.hasTitle
+						? titleFromBasename(file.basename, bucket.before, bucket.after)
+						: system.name,
+				});
+			}
+		}
+
+		for (const bucket of buckets) {
+			bucket.result.notes.sort((a, b) => a.file.basename.localeCompare(b.file.basename));
+		}
+		return buckets
+			.filter(bucket => !bucket.skip)
+			.map(bucket => bucket.result);
+	}
+
+	/**
+	 * Return one coloured indicator per system with a note on each requested day.
+	 *
+	 * The day grid calls this once per render. Its result is cached by the
+	 * displayed dates and system settings, then invalidated by file changes, so
+	 * a 42-cell calendar never repeats the vault scan per cell or per redraw.
+	 */
+	getDateSystemIndicators(dates: moment.Moment[]): Map<string, DateSystemIndicator[]> {
+		const dateStrings = dates.map(date => date.format('YYYY-MM-DD'));
+		const systems = this.dateSystems()
+			.filter(system => formatHasDateToken(system.nameFormat))
+			.map(system => {
+				const parts = splitNameFormat(system.nameFormat);
+				return {
+					system,
+					hasTitle: parts.hasTitle,
+					dates: dates.map((date, index) => ({
+						dateStr: dateStrings[index],
+						before: formatDatePart(date, parts.before),
+						after: formatDatePart(date, parts.after),
+					})),
+				};
+			});
+		const key = JSON.stringify({
+			dates: dateStrings,
+			systems: systems.map(({ system }) => [
+				system.id,
+				system.name,
+				system.folder,
+				system.nameFormat,
+				system.indicatorColor,
+			]),
+		});
+		if (this.dateSystemIndicators && this.dateSystemIndicatorKey === key) {
+			return this.dateSystemIndicators;
+		}
+
+		const matchingIds = new Map<string, Set<string>>();
+		for (const dateStr of dateStrings) matchingIds.set(dateStr, new Set());
+
+		// The only vault traversal: filter a file by system folder first, then
+		// test it against the month's at-most-42 formatted day patterns.
+		for (const file of this.app.vault.getMarkdownFiles()) {
+			for (const entry of systems) {
+				if (!isInFolder(file.path, entry.system.folder)) continue;
+				for (const match of entry.dates) {
+					if (matchesSystemName(file.basename, match.before, match.after, entry.hasTitle)) {
+						matchingIds.get(match.dateStr)?.add(entry.system.id);
+					}
+				}
+			}
+		}
+
+		const result = new Map<string, DateSystemIndicator[]>();
+		for (const dateStr of dateStrings) {
+			const ids = matchingIds.get(dateStr);
+			result.set(dateStr, systems
+				.filter(({ system }) => ids?.has(system.id))
+				.map(({ system }) => ({
+					id: system.id,
+					name: system.name,
+					color: system.indicatorColor,
+				})));
+		}
+		this.dateSystemIndicatorKey = key;
+		this.dateSystemIndicators = result;
+		return result;
+	}
+
+	/**
+	 * Open (creating if needed) the note `system` holds for `date`.
+	 *
+	 * `opts.title` fills the `{title}` token of a many-per-date system and is
+	 * ignored by systems without one. Opens in `opts.leaf` when given,
+	 * otherwise in the active leaf.
+	 */
+	async openDateSystemNote(
+		system: DateSystemSettings,
+		date: moment.Moment,
+		opts?: { title?: string; leaf?: WorkspaceLeaf },
+	): Promise<void> {
+
+		if (!formatHasDateToken(system.nameFormat)) {
+			new Notice(`Waypoint: ${system.name || 'This'} name format needs a date placeholder.`);
+			return;
+		}
+		const parts = splitNameFormat(system.nameFormat);
+		const before = formatDatePart(date, parts.before);
+		const after = formatDatePart(date, parts.after);
+
+		let basename: string;
+		if (parts.hasTitle) {
+			const title = sanitizeTitle(opts?.title || '');
+			// Public method, so a caller can legitimately hand us nothing;
+			// creating "2026-09-07 - .md" would be worse than refusing.
+			if (!title) {
+				new Notice(`Waypoint: a ${system.name.toLowerCase()} note needs a title.`);
+				return;
+			}
+			basename = before + title + after;
+		} else {
+			basename = before + after;
+		}
+
+		const fullPath = system.folder ? `${system.folder}/${basename}.md` : `${basename}.md`;
+
+		let file = this.app.vault.getFileByPath(fullPath);
+		if (!file) {
+			file = await this.createDatedNote(fullPath, system, date);
+			if (!file) return;
+		}
+
+		const target = opts?.leaf || this.app.workspace.getLeaf(false);
+		await target.openFile(file);
+	}
 
 	/**
 	 * Open (creating if needed) the period note for `date`.
 	 * Opens in `leaf` when given, otherwise in the active leaf.
 	 */
 	async openPeriodNote(period: PeriodKey, date: moment.Moment, leaf?: WorkspaceLeaf): Promise<void> {
-		const config = PERIOD_CONFIGS[period];
-		const periodSettings = this.settings[config.key];
-		const filename = date.format(periodSettings.nameFormat) + '.md';
-		const fullPath = periodSettings.folder
-			? `${periodSettings.folder}/${filename}`
-			: filename;
-
-		let file = this.app.vault.getFileByPath(fullPath);
-		if (!file) {
-			file = await this.createPeriodNote(fullPath, periodSettings, date, config.label);
-			if (!file) return;
-		}
-
-		const target = leaf || this.app.workspace.getLeaf(false);
-		await target.openFile(file);
+		await this.openDateSystemNote(this.periodAsDateSystem(period), date, { leaf });
 	}
 
 	/**
-	 * Create a period note from its template, or from minimal frontmatter.
+	 * Create a date system's note from its template, or from minimal frontmatter.
 	 *
 	 * Every failure path names the offending path and the reason: the usual
 	 * cause is a configured folder that does not exist yet, which `vault.create`
 	 * refuses outright rather than creating.
 	 */
-	private async createPeriodNote(
+	private async createDatedNote(
 		fullPath: string,
-		periodSettings: PeriodNoteSettings,
+		system: DateSystemSettings,
 		date: moment.Moment,
-		label: string,
 	): Promise<TFile | null> {
-		const noun = label.toLowerCase();
+		const noun = system.name.toLowerCase();
 		const slash = fullPath.lastIndexOf('/');
 		const folder = slash < 0 ? '' : fullPath.slice(0, slash);
 
@@ -563,7 +817,7 @@ export default class WaypointPlugin extends Plugin {
 			return null;
 		}
 
-		const configuredTemplate = periodSettings.templateFile;
+		const configuredTemplate = system.templateFile;
 		const templateFile = this.resolveTemplateFile(configuredTemplate);
 
 		let content: string;
@@ -579,7 +833,7 @@ export default class WaypointPlugin extends Plugin {
 				return null;
 			}
 		} else {
-			content = `---\ntype: ${periodSettings.typeProperty}\ndate: ${date.format('YYYY-MM-DD')}\n---\n\n`;
+			content = `---\ntype: ${system.typeProperty}\ndate: ${date.format('YYYY-MM-DD')}\n---\n\n`;
 		}
 
 		let file: TFile;
@@ -733,3 +987,12 @@ const DIAGNOSTIC_NOTICE_MS = 10000;
 function describeError(err: unknown): string {
 	return err instanceof Error ? err.message : String(err);
 }
+
+/**
+ * Format one half of a split name format. Moment falls back to its default
+ * ISO output when handed an empty format string, so an empty half must never
+ * reach it.
+ */
+function formatDatePart(date: moment.Moment, part: string): string {
+	return part ? date.format(part) : '';
+}

src/settings-tab.ts

@@ -1,12 +1,41 @@
-import { Setting, PluginSettingTab, App, setIcon } from 'obsidian';
+import { Setting, PluginSettingTab, App, setIcon, AbstractInputSuggest, TFile } from 'obsidian';
 import type WaypointPlugin from 'src/main';
-import { WaypointSettings, DEFAULT_SETTINGS, PeriodNoteSettings } from 'src/settings';
+import { WaypointSettings, DEFAULT_SETTINGS, DEFAULT_DATE_SYSTEM, PeriodNoteSettings } from 'src/settings';
+import { formatHasDateToken } from 'src/utils/date-systems';
+
+/**
+ * Vault-wide Markdown-file suggester for template-path fields, matching
+ * Obsidian's native suggest popup (same base class Templater's own template
+ * pickers use) rather than the browser's unstyled `<datalist>` dropdown.
+ */
+class TemplateFileSuggest extends AbstractInputSuggest<TFile> {
+	constructor(app: App, private inputEl: HTMLInputElement) {
+		super(app, inputEl);
+	}
+
+	getSuggestions(query: string): TFile[] {
+		const q = query.toLowerCase();
+		return this.app.vault.getMarkdownFiles()
+			.filter(file => file.path.toLowerCase().includes(q))
+			.slice(0, 200);
+	}
+
+	renderSuggestion(file: TFile, el: HTMLElement): void {
+		el.setText(file.path.replace(/\.md$/, ''));
+	}
+
+	selectSuggestion(file: TFile): void {
+		this.setValue(file.path.replace(/\.md$/, ''));
+		this.inputEl.trigger('input');
+		this.close();
+	}
+}
 
 export class WaypointSettingTab extends PluginSettingTab {
 	private plugin: WaypointPlugin;
 	private settings: WaypointSettings;
 	private onSettingsChange: () => void;
-	private activeTab: 'calendar' | 'periodic' | 'recent' | 'display' | 'about' = 'calendar';
+	private activeTab: 'calendar' | 'periodic' | 'systems' | 'recent' | 'display' | 'about' = 'calendar';
 
 	constructor(app: App, plugin: WaypointPlugin, settings: WaypointSettings, onSettingsChange: () => void) {
 		super(app, plugin);
@@ -24,6 +53,7 @@ export class WaypointSettingTab extends PluginSettingTab {
 		const tabs = [
 			{ key: 'calendar' as const, label: 'Calendar' },
 			{ key: 'periodic' as const, label: 'Periodic Notes' },
+			{ key: 'systems' as const, label: 'Date systems' },
 			{ key: 'recent' as const, label: 'Recent Files' },
 			{ key: 'display' as const, label: 'Display' },
 			{ key: 'about' as const, label: 'About' },
@@ -49,6 +79,9 @@ export class WaypointSettingTab extends PluginSettingTab {
 			case 'periodic':
 				this.renderPeriodicTab(tabContent);
 				break;
+			case 'systems':
+				this.renderSystemsTab(tabContent);
+				break;
 			case 'recent':
 				this.renderRecentTab(tabContent);
 				break;
@@ -91,6 +124,32 @@ export class WaypointSettingTab extends PluginSettingTab {
 						this.saveAndRefresh();
 					});
 			});
+
+		new Setting(container)
+			.setName('Indicator style')
+			.setDesc('Show one neutral dot for any dated note, or one coloured dot for each configured date system.')
+			.addDropdown((dropdown) => {
+				dropdown
+					.addOption('any', 'Single dot')
+					.addOption('systems', 'Colour by note system')
+					.setValue(this.settings.calendar.indicatorMode)
+					.onChange((value: 'any' | 'systems') => {
+						this.settings.calendar.indicatorMode = value;
+						this.saveAndRefresh();
+					});
+			});
+
+		new Setting(container)
+			.setName('Daily indicator colour')
+			.setDesc('Colour for daily-note dots when using “Colour by note system”.')
+			.addColorPicker((color) => {
+				color
+					.setValue(this.settings.calendar.dailyIndicatorColor)
+					.onChange((value) => {
+						this.settings.calendar.dailyIndicatorColor = value;
+						this.saveAndRefresh();
+					});
+			});
 	}
 
 	// ═══════════════════════════════
@@ -134,10 +193,11 @@ export class WaypointSettingTab extends PluginSettingTab {
 
 		new Setting(container)
 			.setName('Template file')
-			.setDesc(`Path to the template file (without .md extension).`)
+			.setDesc('Path to the template file. The .md extension is optional.')
 			.addText((text) => {
 				text.setPlaceholder('Templates/Daily note');
 				text.setValue(period.templateFile);
+				new TemplateFileSuggest(this.app, text.inputEl);
 				text.onChange((value) => {
 					period.templateFile = value;
 					this.saveAndRefresh();
@@ -157,6 +217,152 @@ export class WaypointSettingTab extends PluginSettingTab {
 			});
 	}
 
+	// ═══════════════════════════════
+	//  Date systems tab
+	// ═══════════════════════════════
+
+	private renderSystemsTab(container: HTMLElement): void {
+		const intro = new DocumentFragment();
+		intro.createDiv({ text: 'A date system is a folder of notes whose filenames start with a date. Each one appears in the calendar\'s right-click menu for that day.' });
+		intro.createDiv({ text: 'The daily note is configured under Periodic Notes and always comes first in that menu.' });
+		intro.createDiv({ text: 'Name format is a moment.js format. Literal words need bracket escaping, e.g. YYYY-MM-DD - [Journal].' });
+		intro.createDiv({ text: 'Include {title} for systems that hold many notes per date, such as meetings: the text before the token finds the existing notes, and the token marks where a typed title goes. Without it, a date has exactly one note.' });
+
+		new Setting(container)
+			.setHeading()
+			.setName('Date systems')
+			.setDesc(intro);
+
+		this.settings.dateSystems.forEach((system, i, arr) => {
+			new Setting(container)
+				.setHeading()
+				.setName(system.name || 'Untitled system')
+				.addExtraButton((btn) => {
+					btn
+						.setIcon('arrow-up')
+						.setTooltip('Move up')
+						.setDisabled(i === 0)
+						.onClick(async () => {
+							if (i === 0) return;
+							const above = arr[i - 1];
+							arr[i - 1] = arr[i];
+							arr[i] = above;
+							await this.saveAndRefresh();
+							this.display();
+						});
+				})
+				.addExtraButton((btn) => {
+					btn
+						.setIcon('arrow-down')
+						.setTooltip('Move down')
+						.setDisabled(i === arr.length - 1)
+						.onClick(async () => {
+							if (i === arr.length - 1) return;
+							const below = arr[i + 1];
+							arr[i + 1] = arr[i];
+							arr[i] = below;
+							await this.saveAndRefresh();
+							this.display();
+						});
+				})
+				.addExtraButton((btn) => {
+					btn
+						.setIcon('trash')
+						.setTooltip('Delete this date system')
+						.onClick(async () => {
+							arr.splice(i, 1);
+							await this.saveAndRefresh();
+							this.display();
+						});
+				});
+
+			this.addSystemTextSetting(container,
+				'Name', 'Label shown in the calendar right-click menu.',
+				system, 'name', 'Journal',
+			);
+			this.addSystemTextSetting(container,
+				'Folder', 'Folder these notes live in.',
+				system, 'folder', 'periodic/journal',
+			);
+
+			const formatSetting = this.addSystemTextSetting(container,
+				'Name format', 'Filename format (moment.js format). Include {title} for many notes per date.',
+				system, 'nameFormat', 'YYYY-MM-DD - {title}',
+			);
+			// A blank row is still being filled in, so only warn once something was typed.
+			if (system.nameFormat && !formatHasDateToken(system.nameFormat)) {
+				formatSetting.descEl.createDiv({
+					cls: 'waypoint-settings-warning',
+					text: 'This name format has no date placeholder, so it will never match or create dated notes.',
+				});
+			}
+
+			this.addSystemTextSetting(container,
+				'Template file', 'Path to the template file. The .md extension is optional.',
+				system, 'templateFile', 'resources/template/journal', true,
+			);
+			this.addSystemTextSetting(container,
+				'Type property', `Fallback value for the 'type' frontmatter property, used when no template is found.`,
+				system, 'typeProperty', 'journal-note',
+			);
+			this.addSystemTextSetting(container,
+				'Icon', 'Lucide icon name for the menu item. Browse names at lucide.dev.',
+				system, 'icon', 'book-open',
+			);
+
+			new Setting(container)
+				.setName('Indicator colour')
+				.setDesc('Colour for this system’s dot when using “Colour by note system”.')
+				.addColorPicker((color) => {
+					color
+						.setValue(system.indicatorColor)
+						.onChange((value) => {
+							system.indicatorColor = value;
+							this.saveAndRefresh();
+						});
+				});
+		});
+
+		new Setting(container)
+			.addButton((btn) =>
+				btn
+					.setButtonText('Add date system')
+					.setCta()
+					.onClick(async () => {
+						this.settings.dateSystems.push(Object.assign(
+							{ id: `ds-${Date.now()}-${Math.random().toString(36).slice(2, 6)}` },
+							DEFAULT_DATE_SYSTEM,
+						));
+						await this.saveAndRefresh();
+						this.display();
+					}),
+			);
+	}
+
+	/** Returns the Setting so callers can append validation notices to its description. */
+	private addSystemTextSetting<K extends string>(
+		container: HTMLElement,
+		name: string,
+		desc: string,
+		obj: Record<K, string>,
+		key: K,
+		placeholder: string,
+		suggestTemplates?: boolean,
+	): Setting {
+		return new Setting(container)
+			.setName(name)
+			.setDesc(desc)
+			.addText((text) => {
+				text.setPlaceholder(placeholder);
+				text.setValue(obj[key]);
+				if (suggestTemplates) new TemplateFileSuggest(this.app, text.inputEl);
+				text.onChange((value) => {
+					obj[key] = value;
+					this.saveAndRefresh();
+				});
+			});
+	}
+
 	// ═══════════════════════════════
 	//  Recent Files tab
 	// ═══════════════════════════════

src/settings.ts

@@ -7,9 +7,48 @@ export interface PeriodNoteSettings {
 	typeProperty: string;
 }
 
+/**
+ * A folder of notes whose filenames begin with a date — the vault's "systems":
+ * daily notes, a journal, meeting notes.
+ *
+ * `nameFormat` is a moment format string, so literal text needs bracket
+ * escaping (`YYYY-MM-DD - [Journal]`). When it contains `{title}` the system
+ * holds many notes per date and the token marks where the free-text title
+ * goes; without it a date maps to exactly one filename.
+ */
+export interface DateSystemSettings {
+	/** Stable across edits and reordering, so the settings UI can key rows. */
+	id: string;
+	/** Shown in the calendar's right-click menu. */
+	name: string;
+	folder: string;
+	nameFormat: string;
+	templateFile: string;
+	typeProperty: string;
+	/** Lucide icon name for the menu item. */
+	icon: string;
+	/** CSS colour for this system's calendar indicator. */
+	indicatorColor: string;
+}
+
+/** Field defaults for a newly added system, and the merge base for saved ones. */
+export const DEFAULT_DATE_SYSTEM: Omit<DateSystemSettings, 'id'> = {
+	name: '',
+	folder: '',
+	nameFormat: 'YYYY-MM-DD - {title}',
+	templateFile: '',
+	typeProperty: '',
+	icon: 'file',
+	indicatorColor: '#64748b',
+};
+
 export interface CalendarSettings {
 	firstDayOfWeek: number; // 0=Sunday, 1=Monday
 	showNoteIndicators: boolean;
+	/** Single neutral dot, or a dot per day-scoped date system. */
+	indicatorMode: 'any' | 'systems';
+	/** Colour used by the synthesized daily system in `systems` mode. */
+	dailyIndicatorColor: string;
 }
 
 export interface RecentFilesSettings {
@@ -36,6 +75,8 @@ export interface WaypointSettings {
 	monthly: PeriodNoteSettings;
 	quarterly: PeriodNoteSettings;
 	yearly: PeriodNoteSettings;
+	/** Day-scoped systems beyond the daily note, in menu order. */
+	dateSystems: DateSystemSettings[];
 	recentFiles: RecentFilesSettings;
 	display: DisplaySettings;
 }
@@ -44,6 +85,8 @@ export const DEFAULT_SETTINGS: WaypointSettings = {
 	calendar: {
 		firstDayOfWeek: 1, // Monday
 		showNoteIndicators: true,
+		indicatorMode: 'systems',
+		dailyIndicatorColor: '#3b82f6',
 	},
 	daily: {
 		folder: 'periodic/daily',
@@ -75,6 +118,28 @@ export const DEFAULT_SETTINGS: WaypointSettings = {
 		nameFormat: 'YYYY',
 		typeProperty: 'yearly-note',
 	},
+	dateSystems: [
+		{
+			id: 'journal',
+			name: 'Journal',
+			folder: 'periodic/journal',
+			nameFormat: 'YYYY-MM-DD - [Journal]',
+			templateFile: '',
+			typeProperty: 'journal',
+			icon: 'book-open',
+			indicatorColor: '#22c55e',
+		},
+		{
+			id: 'meetings',
+			name: 'Meeting',
+			folder: 'periodic/meetings',
+			nameFormat: 'YYYY-MM-DD - {title}',
+			templateFile: '',
+			typeProperty: 'meeting',
+			icon: 'users',
+			indicatorColor: '#a855f7',
+		},
+	],
 	recentFiles: {
 		maxItems: 50,
 		updateOn: 'file-open',

src/utils/date-systems.ts

@@ -0,0 +1,103 @@
+// ── Date system filename helpers ──
+//
+// A "date system" is a folder of notes whose filenames begin with a date:
+//
+//   periodic/daily/2026-09-07.md                      one per date
+//   periodic/journal/2026-09-07 - Journal.md           one per date
+//   periodic/meetings/2026-09-07 - Meeting w Mark.md    many per date
+//
+// The system's `nameFormat` is a moment format string. When it contains
+// `{title}` the system holds many notes per date: the part before the token is
+// the date prefix used to find them, and the token marks where a free-text
+// title goes when creating one.
+//
+// This module imports nothing from 'obsidian' so it stays unit-testable in
+// plain node. Callers do the moment formatting and pass the results in.
+
+export const TITLE_TOKEN = '{title}';
+
+export interface NameFormatParts {
+	/** Moment format for the text before the title. */
+	before: string;
+	/** Moment format for the text after the title. Empty for most systems. */
+	after: string;
+	/** True when the format carries a title token, i.e. many notes per date. */
+	hasTitle: boolean;
+}
+
+/**
+ * Split a name format around its title token.
+ *
+ * The split has to happen before moment sees the string: `t`, `i`, `l` and `e`
+ * are all live moment tokens, so formatting `{title}` directly would mangle it.
+ */
+export function splitNameFormat(nameFormat: string): NameFormatParts {
+	const idx = nameFormat.indexOf(TITLE_TOKEN);
+	if (idx < 0) return { before: nameFormat, after: '', hasTitle: false };
+	return {
+		before: nameFormat.slice(0, idx),
+		after: nameFormat.slice(idx + TITLE_TOKEN.length),
+		hasTitle: true,
+	};
+}
+
+/** Whether `path` sits in `folder` or any subfolder. An empty folder is the vault root. */
+export function isInFolder(path: string, folder: string): boolean {
+	if (!folder) return true;
+	const prefix = folder.endsWith('/') ? folder : `${folder}/`;
+	return path.startsWith(prefix);
+}
+
+/**
+ * Whether `basename` is a note of a system whose formatted name parts are
+ * `before` and `after`.
+ *
+ * One-per-date systems must match the whole basename. Many-per-date systems
+ * match on the date prefix, since the middle is a free-text title.
+ */
+export function matchesSystemName(
+	basename: string,
+	before: string,
+	after: string,
+	hasTitle: boolean,
+): boolean {
+	if (!hasTitle) return basename === before + after;
+	// A format of just `{title}` formats to an empty prefix, which would claim
+	// every file in the folder for every date. Treat it as matching nothing;
+	// the settings tab flags the format as missing a date instead.
+	if (!before) return false;
+	if (basename.length < before.length + after.length) return false;
+	return basename.startsWith(before) && basename.endsWith(after);
+}
+
+/**
+ * The free-text part of a many-per-date basename, for use as a menu label.
+ * Falls back to the whole basename when the affixes do not line up.
+ */
+export function titleFromBasename(basename: string, before: string, after: string): string {
+	const start = basename.startsWith(before) ? before.length : 0;
+	const end = after && basename.endsWith(after)
+		? basename.length - after.length
+		: basename.length;
+	if (end <= start) return basename;
+	return basename.slice(start, end).trim() || basename;
+}
+
+/**
+ * Characters Obsidian rejects in filenames, plus the link-syntax characters
+ * (`#^[]|`) it refuses to index cleanly. Collapsed to a dash so a typed title
+ * like "Meeting w/ Mark" still produces a creatable filename.
+ */
+const ILLEGAL_FILENAME_CHARS = /[\\/:*?"<>|#^[\]]/g;
+
+export function sanitizeTitle(title: string): string {
+	return title.replace(ILLEGAL_FILENAME_CHARS, '-').replace(/\s+/g, ' ').trim();
+}
+
+/** Whether a name format resolves to a usable date prefix at all. */
+export function formatHasDateToken(nameFormat: string): boolean {
+	const { before } = splitNameFormat(nameFormat);
+	// Strip bracket-escaped literals, then look for any moment date token.
+	const unescaped = before.replace(/\[[^\]]*\]/g, '');
+	return /[YMDQGWEwdgeo]/.test(unescaped);
+}

src/views/waypoint-view.ts

@@ -15,6 +15,7 @@ import {
 	type PaneType,
 } from 'obsidian';
 import type WaypointPlugin from 'src/main';
+import type { DateSystemNotes } from 'src/main';
 import { getMonthGrid } from 'src/utils/date-utils';
 import { BookmarkItem } from 'src/models/bookmark';
 
@@ -90,7 +91,6 @@ export class WaypointView extends ItemView {
 
 	private renderCalendar(): void {
 		const section = this.contentEl.createDiv({ cls: 'waypoint-section' });
-		section.createDiv({ cls: 'waypoint-section-header', text: 'Calendar' });
 
 		const cal = section.createDiv({ cls: 'waypoint-calendar' });
 
@@ -180,6 +180,14 @@ export class WaypointView extends ItemView {
 			this.plugin.settings.calendar.firstDayOfWeek,
 		);
 
+		const systemIndicators = this.plugin.settings.calendar.showNoteIndicators
+			&& this.plugin.settings.calendar.indicatorMode === 'systems'
+			? this.plugin.getDateSystemIndicators(weeks.reduce<moment.Moment[]>(
+				(dates, week) => dates.concat(week.days.map(day => day.date)),
+				[],
+			))
+			: null;
+
 		for (const week of weeks) {
 			const row = tbody.createEl('tr');
 
@@ -210,9 +218,21 @@ export class WaypointView extends ItemView {
 
 				if (this.plugin.settings.calendar.showNoteIndicators) {
 					const dateStr = day.date.format('YYYY-MM-DD');
+					if (this.plugin.settings.calendar.indicatorMode === 'any') {
 						if (this.plugin.hasNoteForDate(dateStr)) {
 							cell.addClass('has-note');
 						}
+					} else {
+						const indicators = systemIndicators?.get(dateStr) || [];
+						if (indicators.length > 0) {
+							const dots = cell.createDiv({ cls: 'waypoint-day-indicators' });
+							for (const indicator of indicators) {
+								const dot = dots.createSpan({ cls: 'waypoint-day-indicator' });
+								dot.style.setProperty('--waypoint-indicator-color', indicator.color);
+								setTooltip(dot, indicator.name);
+							}
+						}
+					}
 				}
 
 				cell.addEventListener('click', () => {
@@ -224,6 +244,11 @@ export class WaypointView extends ItemView {
 						this.plugin.openPeriodNote('day', day.date, this.app.workspace.getLeaf('tab'));
 					}
 				});
+				cell.addEventListener('contextmenu', (event: MouseEvent) => {
+					event.preventDefault();
+					event.stopPropagation();
+					this.showDayContextMenu(event, day.date);
+				});
 			}
 		}
 
@@ -236,6 +261,79 @@ export class WaypointView extends ItemView {
 		this.redraw();
 	}
 
+	/**
+	 * Right-click menu for a day cell: every date system's existing notes for
+	 * that date, plus the actions that would create the ones it is missing.
+	 */
+	private showDayContextMenu(event: MouseEvent, date: moment.Moment): void {
+		const menu = new Menu();
+
+		menu.addItem((i) => i.setTitle(date.format('dddd, MMMM D, YYYY')).setIsLabel(true));
+
+		for (const bucket of this.plugin.findDateSystemNotes(date)) {
+			// Many-per-date systems can always take another note; one-per-date
+			// systems only offer creation while their single note is missing.
+			const canCreate = bucket.multiple || bucket.notes.length === 0;
+			if (bucket.notes.length + (canCreate ? 1 : 0) === 0) continue;
+
+			menu.addSeparator();
+
+			for (const note of bucket.notes) {
+				menu.addItem((i) =>
+					i
+						.setTitle(note.label)
+						.setIcon(bucket.system.icon)
+						.onClick((evt) => this.focusFile(note.file, Keymap.isModEvent(evt))),
+				);
+			}
+
+			if (!canCreate) continue;
+
+			const noun = bucket.system.name.toLowerCase();
+			menu.addItem((i) =>
+				i
+					// The ellipsis promises the prompt that a free-text title needs.
+					.setTitle(bucket.multiple ? `New ${noun} note…` : `New ${noun} note`)
+					.setIcon('plus')
+					.onClick((evt) => this.createDateSystemNote(bucket, date, Keymap.isModEvent(evt))),
+			);
+		}
+
+		menu.showAtPosition({ x: event.clientX, y: event.clientY });
+	}
+
+	/**
+	 * Creates a date system's note, asking for a title first when the system
+	 * holds many notes per date. A held modifier opens the result in a new pane.
+	 */
+	private createDateSystemNote(bucket: DateSystemNotes, date: moment.Moment, newLeaf: PaneType | boolean): void {
+		if (!bucket.multiple) {
+			void this.plugin.openDateSystemNote(bucket.system, date, {
+				leaf: newLeaf ? this.app.workspace.getLeaf(newLeaf) : undefined,
+			});
+			return;
+		}
+
+		const name = bucket.system.name;
+		new PromptModal(
+			this.app,
+			{
+				title: `New ${name.toLowerCase()} note`,
+				placeholder: `${name} with…`,
+				cta: 'Create',
+			},
+			(title) => {
+				// `getLeaf` materialises the pane immediately, so the target pane is
+				// resolved only after the title is confirmed — cancelling the prompt
+				// must not leave an empty tab behind.
+				void this.plugin.openDateSystemNote(bucket.system, date, {
+					title,
+					leaf: newLeaf ? this.app.workspace.getLeaf(newLeaf) : undefined,
+				});
+			},
+		).open();
+	}
+
 	// ════════════════════════════════════════
 	//  Recent Files panel
 	// ════════════════════════════════════════
@@ -1062,7 +1160,7 @@ export class WaypointView extends ItemView {
 	}
 
 	private promptRename(item: BookmarkItem): void {
-		new RenameModal(this.app, item.label, (newLabel) => {
+		new PromptModal(this.app, { title: 'Rename bookmark', initialValue: item.label }, (newLabel) => {
 			if (newLabel && newLabel.trim()) {
 				this.plugin.updateBookmark(item.id, { label: newLabel.trim() });
 			}
@@ -1077,24 +1175,34 @@ export class WaypointView extends ItemView {
 	}
 }
 
-// ── Rename modal ──
+// ── Text prompt modal ──
 
-class RenameModal extends Modal {
-	private currentValue: string;
+interface PromptModalOptions {
+	title: string;
+	placeholder?: string;
+	initialValue?: string;
+	/** Submit button label. Defaults to 'Save'. */
+	cta?: string;
+}
+
+/** Single-line text prompt, shared by bookmark renaming and note creation. */
+class PromptModal extends Modal {
+	private options: PromptModalOptions;
 	private onSubmit: (value: string) => void;
 
-	constructor(app: App, currentValue: string, onSubmit: (value: string) => void) {
+	constructor(app: App, options: PromptModalOptions, onSubmit: (value: string) => void) {
 		super(app);
-		this.currentValue = currentValue;
+		this.options = options;
 		this.onSubmit = onSubmit;
 	}
 
 	onOpen(): void {
-		this.titleEl.setText('Rename bookmark');
+		this.titleEl.setText(this.options.title);
 
 		const input = this.contentEl.createEl('input', {
 			type: 'text',
-			value: this.currentValue,
+			value: this.options.initialValue ?? '',
+			placeholder: this.options.placeholder ?? '',
 		});
 		input.style.width = '100%';
 		input.style.marginBottom = '12px';
@@ -1107,7 +1215,7 @@ class RenameModal extends Modal {
 		cancelBtn.style.marginRight = '8px';
 		cancelBtn.addEventListener('click', () => this.close());
 
-		const saveBtn = btnContainer.createEl('button', { text: 'Save', cls: 'mod-cta' });
+		const saveBtn = btnContainer.createEl('button', { text: this.options.cta ?? 'Save', cls: 'mod-cta' });
 		saveBtn.addEventListener('click', () => {
 			this.onSubmit(input.value);
 			this.close();

styles.css

@@ -58,29 +58,34 @@
 
 .waypoint-calendar {
 	font-size: var(--font-ui-small);
+	padding: 8px;
+	border: 1px solid var(--background-modifier-border);
+	border-radius: 10px;
+	background: var(--background-primary-alt);
 }
 
 .waypoint-calendar-top {
 	display: flex;
 	align-items: center;
 	justify-content: space-between;
-	margin-bottom: 10px;
+	margin-bottom: 8px;
 }
 
 .waypoint-calendar-breadcrumb {
 	display: flex;
 	align-items: center;
-	gap: 6px;
+	gap: 4px;
 	font-size: var(--font-ui-medium);
 	font-weight: var(--font-semibold);
-	padding: 4px 0;
+	padding: 2px 0;
 }
 
 .waypoint-calendar-breadcrumb .waypoint-clickable {
 	color: var(--text-muted);
 	cursor: var(--cursor-link, pointer);
-	padding: 1px 4px;
+	padding: 2px 4px;
 	border-radius: 4px;
+	transition: color 80ms, background-color 80ms;
 }
 
 .waypoint-calendar-breadcrumb .waypoint-clickable:hover {
@@ -90,23 +95,25 @@
 
 .waypoint-calendar .waypoint-separator {
 	color: var(--text-faint);
-	margin: 0 2px;
+	margin: 0;
 }
 
 .waypoint-calendar-today-group {
 	display: flex;
 	align-items: center;
-	gap: 2px;
+	gap: 1px;
 }
 
 .waypoint-calendar-today-group button {
 	background: none;
 	border: none;
 	cursor: var(--cursor-link, pointer);
-	padding: 2px 6px;
+	padding: 2px 5px;
 	border-radius: 4px;
 	color: var(--text-muted);
 	font-size: var(--font-ui-small);
+	transition: color 80ms, background-color 80ms;
+	box-shadow: none;
 }
 
 .waypoint-calendar-today-group button:hover {
@@ -121,30 +128,34 @@
 .waypoint-calendar table {
 	table-layout: fixed;
 	width: 100%;
-	border-collapse: collapse;
+	border-collapse: separate;
+	border-spacing: 2px 3px;
 }
 
 .waypoint-calendar th,
 .waypoint-calendar td {
 	text-align: center;
-	padding: 4px 2px;
+	padding: 0;
 	font-size: var(--font-ui-small);
-	line-height: 1.6;
 }
 
 .waypoint-calendar th {
+	padding-bottom: 2px;
 	font-weight: var(--font-medium);
 	color: var(--text-faint);
-	font-size: calc(var(--font-ui-small) * 0.85);
+	font-size: calc(var(--font-ui-small) * 0.78);
+	letter-spacing: 0.04em;
+	text-transform: uppercase;
 }
 
 .waypoint-calendar .waypoint-weeknum {
-	font-size: calc(var(--font-ui-small) * 0.75);
+	width: 18px;
+	font-size: calc(var(--font-ui-small) * 0.72);
 	color: var(--text-faint);
 	font-weight: var(--font-light);
 	cursor: var(--cursor-link, pointer);
-	padding: 2px 0;
 	border-radius: 4px;
+	transition: color 80ms, background-color 80ms;
 }
 
 .waypoint-calendar .waypoint-weeknum:hover {
@@ -154,42 +165,71 @@
 
 .waypoint-calendar .waypoint-day {
 	cursor: var(--cursor-link, pointer);
-	min-height: var(--wp-cal-cell-size, 32px);
-	padding: 2px 0;
+	height: var(--wp-cal-cell-size, 32px);
+	box-sizing: border-box;
+	padding: 2px 0 7px;
 	border-radius: 6px;
 	position: relative;
 	width: 100%;
 	vertical-align: middle;
+	transition: color 80ms, background-color 80ms, box-shadow 80ms;
 }
 
 .waypoint-calendar .waypoint-day:hover {
-	background-color: var(--background-modifier-active-hover);
+	background-color: var(--background-modifier-hover);
 }
 
 .waypoint-calendar .waypoint-day.other-month {
-	opacity: 0.35;
+	color: var(--text-faint);
+	opacity: 0.5;
 }
 
 .waypoint-calendar .waypoint-day.today {
 	color: var(--text-accent);
-	border: 1px solid var(--text-accent);
 	font-weight: var(--font-semibold);
+	box-shadow: inset 0 0 0 1px var(--text-accent);
 }
 
+.waypoint-calendar .waypoint-day.today:hover {
+	background-color: var(--background-modifier-active-hover);
+}
+
+/* Single-dot mode preserves the pre-date-systems indicator. */
 .waypoint-calendar .waypoint-day.has-note::after {
 	content: '';
-	display: block;
+	position: absolute;
+	left: 50%;
+	bottom: 3px;
 	width: 4px;
 	height: 4px;
 	border-radius: 50%;
 	background-color: var(--text-faint);
-	margin: 0 auto;
+	transform: translateX(-50%);
 }
 
 .waypoint-calendar .waypoint-day.today.has-note::after {
 	background-color: var(--text-accent);
 }
 
+/* Colour-by-system mode: one dot per matching system, in Settings order. */
+.waypoint-day-indicators {
+	position: absolute;
+	right: 0;
+	bottom: 3px;
+	left: 0;
+	display: flex;
+	justify-content: center;
+	gap: 3px;
+}
+
+.waypoint-day-indicator {
+	width: 5px;
+	height: 5px;
+	border-radius: 50%;
+	background-color: var(--waypoint-indicator-color);
+	box-shadow: 0 0 0 1px var(--background-primary);
+}
+
 /* ── Recent Files ── */
 
 .waypoint-recent-filter {
@@ -420,3 +460,11 @@ button.waypoint-calendar-today-btn {
 	margin-right: auto;
 	cursor: var(--cursor-link, pointer);
 }
+
+/* ── Settings: date systems ── */
+
+.waypoint-settings-warning {
+	margin-top: 4px;
+	color: var(--text-error);
+	font-size: var(--font-ui-smaller);
+}