tuiboard 0.5.5 → 0.6.0

package/.tuiboard/config.example.yaml

@@ -47,3 +47,20 @@ archive_column: Archive
 #   - C:/Users/you/.config/tuiboard/code-resume.nu
 #   - "{cwd}"
 #   - "{sessionId}"
+
+# Optional: overlay read-only calendar events on the Agenda (the 24h timeline).
+# Connect a provider with `tuiboard calendar-setup google` / `... microsoft`,
+# which opens the auth flow and prints the exact block to paste here. Bring your
+# own credentials — nothing is hosted, nothing leaves your machine. All-day
+# events are skipped; each calendar keeps its own color. Paths support `~`.
+#
+# calendars:
+#   google:
+#     enabled: true
+#     token: ~/.config/tuiboard/google_token.json
+#     # color: "#e8a05c"            # fallback when a calendar has no color
+#   microsoft:
+#     enabled: true
+#     config: ~/.config/tuiboard/azure_config.json
+#     token_cache: ~/.config/tuiboard/ms_token.json
+#     # color: "#b39ddb"

package/README.md

@@ -98,7 +98,12 @@ https://github.com/NazzarenoGiannelli/tuiboard). Set it up for me from scratch:
    home path) with a `boards:` list pointing at those files by ABSOLUTE path,
    plus `assignees: [...]`, `done_column: Done`, `archive_column: Archive`.
 4. Do NOT configure the Agent view — tuiboard reads `~/.claude` automatically.
-5. Show me the final config, then tell me to run `tuiboard`, and how to add a
+5. Ask me whether I want to overlay my Google Calendar or Microsoft 365 events
+   on the Agenda. If yes, tell me to run `tuiboard calendar-setup google` (or
+   `microsoft`) — it interviews me, opens the browser, and prints the exact
+   `calendars:` YAML block to add. Don't try to do the OAuth yourself. If no,
+   skip it (it's optional and can be added later).
+6. Show me the final config, then tell me to run `tuiboard`, and how to add a
    board later (create a new `.md` and append it to the `boards:` list).
 
 Confirm the directory and file names with me before writing any files.
@@ -137,6 +142,48 @@ archive_column: Archive
 # resume_command: ["nu", "C:/Users/you/.config/tuiboard/code-resume.nu", "{cwd}", "{sessionId}"]
 ```
 
+## Calendars (Agenda overlay)
+
+The **Agenda** zone (the 24h timeline) can overlay read-only events from Google
+Calendar and Microsoft 365 alongside your time-blocked tasks — rendered as
+colored `📅` blocks you can't edit, so the day's real shape is visible at a
+glance. All-day events are skipped; each calendar keeps its own color. Events
+are cached 30 min on disk and refreshed every 5 min. **Bring your own
+credentials** — there's nothing to sign up for and nothing leaves your machine.
+
+Connect a calendar with the built-in setup command:
+
+```bash
+tuiboard calendar-setup google      # opens your browser (read-only scope)
+tuiboard calendar-setup microsoft   # device-code flow, no redirect
+```
+
+**Google** needs a one-time OAuth client (free): Google Cloud Console → enable
+*Google Calendar API* → create an *OAuth client ID* (type **Desktop app**) →
+download the JSON to `~/.config/tuiboard/google_credentials.json`, then run the
+command above. **Microsoft** needs an Azure app registration (Public client,
+`Calendars.Read` delegated) whose client ID goes in
+`~/.config/tuiboard/azure_config.json` — running `calendar-setup microsoft` with
+no config writes a template that walks you through it.
+
+After connecting, the command prints the exact YAML to paste into your config:
+
+```yaml
+calendars:
+  google:
+    enabled: true
+    token: ~/.config/tuiboard/google_token.json
+  microsoft:
+    enabled: true
+    config: ~/.config/tuiboard/azure_config.json
+    token_cache: ~/.config/tuiboard/ms_token.json
+```
+
+Paths support `~` and resolve against the config dir if relative. A missing,
+expired, or unconfigured calendar never breaks the board — it just shows no
+events. Set either provider's `enabled: false` (or drop the block) to turn it
+off; add a `color:` to override the fallback block color.
+
 ## Markdown board format
 
 `tuiboard` reads and writes **plain CommonMark** with the Obsidian
@@ -223,6 +270,16 @@ session (until the next terminal resize).
 | `F1` / `F2` / `F3` | Toggle visibility of Virtual / Timeline / Agents zones |
 | `z` | Zoom active zone to full screen |
 
+### Agenda (timeline zone)
+
+| Key | Action |
+|---|---|
+| `[` / `]` | Previous / next day — shows that day's tasks **and** calendar events |
+| `\` | Jump back to today |
+| `c` | Arm mode: click a task, then click a slot to schedule (works from any zone) |
+| `j` / `k` | While armed: nudge the block ±15 min |
+| `+` / `-` | While armed: resize the block's end ±15 min |
+
 ### Task actions (work in board, virtual, AND timeline zones)
 
 | Key | Action |
@@ -261,6 +318,9 @@ session (until the next terminal resize).
 
 ## Status
 
+- **v0.6** — adds the Agenda calendar overlay (Google + Microsoft 365,
+  read-only, BYO credentials) and day-navigation (`[` / `]` / `\`) so you can
+  page tasks and events across days.
 - **v0.5** — daily-driver ready. Kanban + virtual + timeline + agents
   all functional, multi-select, undo, atomic file roundtrip, mouse click,
   responsive layout. Tested on Windows with WezTerm; Linux/macOS should

package/bin/tuiboard.ts

@@ -17,6 +17,13 @@ import { fileURLToPath } from "node:url";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const appPath = join(here, "..", "src", "app.tsx");
+
+// Subcommands that run as a plain CLI (no TUI, no preload needed). Handle them
+// here before re-exec'ing bun for the dashboard.
+if (process.argv[2] === "calendar-setup") {
+  const { runCalendarSetup } = await import("../src/calendar/setup.ts");
+  process.exit(await runCalendarSetup(process.argv.slice(3)));
+}
 const preload = fileURLToPath(import.meta.resolve("@opentui/solid/preload"));
 
 const result = spawnSync(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuiboard",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "description": "Terminal dashboard for markdown task boards. Kanban + Today/Tomorrow + 24h timeline + Claude Code agent view, all in one TUI.",
   "type": "module",
   "license": "MIT",

package/src/calendar/setup.ts

@@ -0,0 +1,337 @@
+/**
+ * One-time OAuth setup for the Agenda calendar overlay.
+ *
+ *   tuiboard calendar-setup google      # browser OAuth (loopback redirect)
+ *   tuiboard calendar-setup microsoft   # device-code flow (no redirect)
+ *   tuiboard calendar-setup             # show usage
+ *
+ * Dependency-light: raw `fetch` + the platform browser, no SDKs. Tokens are
+ * written to the paths your tuiboard config points at (`calendars.google.token`
+ * / `calendars.microsoft.tokenCache`); if there's no `calendars:` block yet we
+ * fall back to `~/.config/tuiboard/` and tell you what to add.
+ *
+ * Runs as a plain CLI (no TUI) — see bin/tuiboard.ts.
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+
+import { loadConfig } from "~/config/loader";
+
+const TUIBOARD_DIR = join(homedir(), ".config", "tuiboard");
+const GOOGLE_SCOPE = "https://www.googleapis.com/auth/calendar.readonly";
+const MS_SCOPE = "Calendars.Read offline_access openid profile";
+
+function expandPath(p: string, root: string): string {
+  if (p.startsWith("~")) return join(homedir(), p.slice(1).replace(/^[/\\]/, ""));
+  return isAbsolute(p) ? p : resolve(root, p);
+}
+
+function openBrowser(url: string): void {
+  try {
+    if (process.platform === "win32") {
+      // `start` is a cmd builtin; the empty "" is the window title arg.
+      spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+    } else if (process.platform === "darwin") {
+      spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+    } else {
+      spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+    }
+  } catch {
+    // fall back to the printed URL
+  }
+}
+
+function writeJson(path: string, data: unknown): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(data, null, 2), "utf-8");
+}
+
+// ─── Google ─────────────────────────────────────────────────────────────────
+
+interface GoogleClientSecrets {
+  client_id?: string;
+  client_secret?: string;
+  auth_uri?: string;
+  token_uri?: string;
+}
+
+async function setupGoogle(credsPath: string, tokenPath: string): Promise<number> {
+  console.log("\n── Google Calendar setup ──────────────────────────────────");
+  if (!existsSync(credsPath)) {
+    console.log(`OAuth client file not found:\n  ${credsPath}\n
+Create it:
+  1. Google Cloud Console → APIs & Services → enable "Google Calendar API"
+  2. Credentials → Create credentials → OAuth client ID
+     Application type: Desktop app
+  3. Download the JSON and save it as the path above
+  4. Re-run: tuiboard calendar-setup google\n`);
+    return 1;
+  }
+
+  let secrets: GoogleClientSecrets;
+  try {
+    const raw = JSON.parse(readFileSync(credsPath, "utf-8")) as {
+      installed?: GoogleClientSecrets;
+      web?: GoogleClientSecrets;
+    } & GoogleClientSecrets;
+    secrets = raw.installed ?? raw.web ?? raw;
+  } catch {
+    console.log(`Could not parse ${credsPath} as JSON.`);
+    return 1;
+  }
+  const clientId = secrets.client_id;
+  const clientSecret = secrets.client_secret;
+  if (!clientId || !clientSecret) {
+    console.log("client_id / client_secret missing from the OAuth client file.");
+    return 1;
+  }
+  const authUri = secrets.auth_uri || "https://accounts.google.com/o/oauth2/auth";
+  const tokenUri = secrets.token_uri || "https://oauth2.googleapis.com/token";
+
+  // Loopback server captures the ?code= redirect.
+  let resolveResult!: (v: { code?: string; error?: string }) => void;
+  const result = new Promise<{ code?: string; error?: string }>((r) => (resolveResult = r));
+  const server = Bun.serve({
+    port: 0,
+    fetch(req) {
+      const u = new URL(req.url);
+      const code = u.searchParams.get("code") ?? undefined;
+      const error = u.searchParams.get("error") ?? undefined;
+      if (code || error) {
+        resolveResult({ code, error });
+        const msg = error
+          ? `Authorization failed: ${error}`
+          : "tuiboard is now connected to Google Calendar. You can close this tab.";
+        return new Response(`<!doctype html><meta charset=utf-8><body style="font:16px system-ui;padding:3rem">${msg}</body>`, {
+          headers: { "content-type": "text/html" },
+        });
+      }
+      return new Response("waiting for Google…", { headers: { "content-type": "text/plain" } });
+    },
+  });
+  const redirectUri = `http://localhost:${server.port}`;
+  const authUrl =
+    `${authUri}?` +
+    new URLSearchParams({
+      client_id: clientId,
+      redirect_uri: redirectUri,
+      response_type: "code",
+      scope: GOOGLE_SCOPE,
+      access_type: "offline",
+      prompt: "consent",
+    }).toString();
+
+  console.log("Opening your browser to authorize Google Calendar (read-only)…");
+  console.log(`If it doesn't open, visit:\n  ${authUrl}\n`);
+  openBrowser(authUrl);
+
+  const { code, error } = await result;
+  server.stop(true);
+  if (error || !code) {
+    console.log(`\nSetup cancelled${error ? `: ${error}` : ""}.`);
+    return 1;
+  }
+
+  const res = await fetch(tokenUri, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      code,
+      client_id: clientId,
+      client_secret: clientSecret,
+      redirect_uri: redirectUri,
+      grant_type: "authorization_code",
+    }),
+  });
+  if (!res.ok) {
+    console.log(`Token exchange failed (${res.status}): ${await res.text()}`);
+    return 1;
+  }
+  const data = (await res.json()) as {
+    access_token?: string;
+    refresh_token?: string;
+    expires_in?: number;
+  };
+  if (!data.access_token || !data.refresh_token) {
+    console.log("Google did not return a refresh token. Revoke prior access and retry.");
+    return 1;
+  }
+  writeJson(tokenPath, {
+    token: data.access_token,
+    refresh_token: data.refresh_token,
+    token_uri: tokenUri,
+    client_id: clientId,
+    client_secret: clientSecret,
+    scopes: [GOOGLE_SCOPE],
+    expiry: data.expires_in ? new Date(Date.now() + data.expires_in * 1000).toISOString() : undefined,
+  });
+  console.log(`\n✓ Google Calendar connected. Token saved:\n  ${tokenPath}\n`);
+  return 0;
+}
+
+// ─── Microsoft 365 ────────────────────────────────────────────────────────────
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+async function setupMicrosoft(configPath: string, tokenPath: string): Promise<number> {
+  console.log("\n── Microsoft 365 setup ────────────────────────────────────");
+  if (!existsSync(configPath)) {
+    writeJson(configPath, {
+      client_id: "YOUR_AZURE_APP_CLIENT_ID",
+      authority: "https://login.microsoftonline.com/common",
+    });
+    console.log(`Azure config template created:\n  ${configPath}\n
+Complete it:
+  1. Azure Portal → App registrations → New registration
+     Supported accounts: "any org directory and personal Microsoft accounts"
+     Redirect URI: Public client/native → http://localhost
+  2. Authentication → enable "Allow public client flows"
+  3. API permissions → Microsoft Graph → Delegated → Calendars.Read
+  4. Put the Application (client) ID into the file above
+  5. Re-run: tuiboard calendar-setup microsoft\n`);
+    return 1;
+  }
+
+  let cfg: { client_id?: string; authority?: string };
+  try {
+    cfg = JSON.parse(readFileSync(configPath, "utf-8")) as typeof cfg;
+  } catch {
+    console.log(`Could not parse ${configPath} as JSON.`);
+    return 1;
+  }
+  const clientId = cfg.client_id;
+  if (!clientId || clientId === "YOUR_AZURE_APP_CLIENT_ID") {
+    console.log(`Set your Azure client_id in ${configPath} first.`);
+    return 1;
+  }
+  const authority = cfg.authority || "https://login.microsoftonline.com/common";
+
+  const dcRes = await fetch(`${authority}/oauth2/v2.0/devicecode`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ client_id: clientId, scope: MS_SCOPE }),
+  });
+  if (!dcRes.ok) {
+    console.log(`Failed to start device flow (${dcRes.status}): ${await dcRes.text()}`);
+    return 1;
+  }
+  const dc = (await dcRes.json()) as {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    message?: string;
+    interval?: number;
+    expires_in?: number;
+  };
+  console.log(`\n  ${dc.message ?? `Go to ${dc.verification_uri} and enter code ${dc.user_code}`}\n`);
+  openBrowser(dc.verification_uri);
+
+  const tokenEndpoint = `${authority}/oauth2/v2.0/token`;
+  let interval = (dc.interval ?? 5) * 1000;
+  const deadline = Date.now() + (dc.expires_in ?? 900) * 1000;
+  while (Date.now() < deadline) {
+    await sleep(interval);
+    const res = await fetch(tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        client_id: clientId,
+        device_code: dc.device_code,
+      }),
+    });
+    const data = (await res.json()) as {
+      access_token?: string;
+      refresh_token?: string;
+      expires_in?: number;
+      error?: string;
+      error_description?: string;
+    };
+    if (data.access_token) {
+      writeJson(tokenPath, {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expiry: data.expires_in
+          ? new Date(Date.now() + data.expires_in * 1000).toISOString()
+          : undefined,
+      });
+      console.log(`\n✓ Microsoft 365 connected. Token saved:\n  ${tokenPath}\n`);
+      return 0;
+    }
+    if (data.error === "authorization_pending") continue;
+    if (data.error === "slow_down") {
+      interval += 5000;
+      continue;
+    }
+    console.log(`\nAuthentication failed: ${data.error_description ?? data.error ?? "unknown error"}`);
+    return 1;
+  }
+  console.log("\nDevice code expired before authorization. Re-run to try again.");
+  return 1;
+}
+
+// ─── Entry ────────────────────────────────────────────────────────────────────
+
+function usage(): void {
+  console.log(`tuiboard calendar-setup — connect a calendar to the Agenda overlay
+
+Usage:
+  tuiboard calendar-setup google      Browser OAuth for Google Calendar
+  tuiboard calendar-setup microsoft   Device-code flow for Microsoft 365
+
+Tokens are written to the paths in your tuiboard config (calendars.google.token
+/ calendars.microsoft.tokenCache), or ~/.config/tuiboard/ if no calendars block
+exists yet. After connecting, add the matching block to your config — the setup
+prints the exact YAML.`);
+}
+
+export async function runCalendarSetup(argv: string[]): Promise<number> {
+  const provider = (argv[0] ?? "").toLowerCase();
+  const cfg = loadConfig();
+  const root = cfg.root;
+
+  if (provider === "google") {
+    const g = cfg.calendars?.google;
+    const credsPath = g?.credentials
+      ? expandPath(g.credentials, root)
+      : join(TUIBOARD_DIR, "google_credentials.json");
+    const tokenPath = g?.token ? expandPath(g.token, root) : join(TUIBOARD_DIR, "google_token.json");
+    const rc = await setupGoogle(credsPath, tokenPath);
+    if (rc === 0 && !g) {
+      console.log(`Add this to your tuiboard config (${cfg.loaded ? "config found" : "create ~/.config/tuiboard/config.yaml"}):
+
+calendars:
+  google:
+    enabled: true
+    token: ${tokenPath}
+`);
+    }
+    return rc;
+  }
+
+  if (provider === "microsoft" || provider === "ms" || provider === "ms365") {
+    const m = cfg.calendars?.microsoft;
+    const configPath = m?.config ? expandPath(m.config, root) : join(TUIBOARD_DIR, "azure_config.json");
+    const tokenPath = m?.tokenCache
+      ? expandPath(m.tokenCache, root)
+      : join(TUIBOARD_DIR, "ms_token.json");
+    const rc = await setupMicrosoft(configPath, tokenPath);
+    if (rc === 0 && !m) {
+      console.log(`Add this to your tuiboard config:
+
+calendars:
+  microsoft:
+    enabled: true
+    config: ${configPath}
+    token_cache: ${tokenPath}
+`);
+    }
+    return rc;
+  }
+
+  usage();
+  return provider ? 1 : 0;
+}

package/src/config/loader.ts

@@ -43,6 +43,36 @@ export interface Config {
    * When unset, tuiboard falls back to opening a tab + `claude --resume <id>`.
    */
   resumeCommand?: string[];
+  /**
+   * Optional read-only calendar feeds merged into the Agenda (timeline) zone.
+   * Paths support `~` and are resolved against the config dir if relative.
+   * Tokens are produced by `tuiboard calendar-setup`.
+   */
+  calendars?: CalendarsConfig;
+}
+
+export interface GoogleCalendarConfig {
+  enabled?: boolean;
+  /** Path to the google_token.json authorized-user file. */
+  token: string;
+  /** Path to the OAuth client google_credentials.json (used by setup only). */
+  credentials?: string;
+  /** Fallback color when a calendar has none of its own. */
+  color?: string;
+}
+
+export interface MicrosoftCalendarConfig {
+  enabled?: boolean;
+  /** Path to azure_config.json ({ client_id, authority }). */
+  config: string;
+  /** Path to the MSAL serialized ms_token_cache.json. */
+  tokenCache: string;
+  color?: string;
+}
+
+export interface CalendarsConfig {
+  google?: GoogleCalendarConfig;
+  microsoft?: MicrosoftCalendarConfig;
 }
 
 export const DEFAULT_CONFIG: Omit<Config, "root" | "loaded" | "boards"> = {
@@ -91,6 +121,56 @@ interface RawConfig {
   done_column: string;
   archive_column: string;
   resume_command: string[];
+  calendars: {
+    google?: {
+      enabled?: boolean;
+      token?: string;
+      credentials?: string;
+      color?: string;
+    };
+    microsoft?: {
+      enabled?: boolean;
+      config?: string;
+      token_cache?: string;
+      color?: string;
+    };
+  };
+}
+
+/** Expand `~` to the home dir; resolve relative paths against the config dir. */
+function expandPath(p: string, root: string): string {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return join(homedir(), p.slice(2));
+  }
+  return isAbsolute(p) ? p : resolve(root, p);
+}
+
+function normalizeCalendars(
+  raw: RawConfig["calendars"] | undefined,
+  root: string,
+): CalendarsConfig | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const out: CalendarsConfig = {};
+  const g = raw.google;
+  if (g && g.token) {
+    out.google = {
+      enabled: g.enabled !== false,
+      token: expandPath(g.token, root),
+      credentials: g.credentials ? expandPath(g.credentials, root) : undefined,
+      color: g.color,
+    };
+  }
+  const m = raw.microsoft;
+  if (m && m.config && m.token_cache) {
+    out.microsoft = {
+      enabled: m.enabled !== false,
+      config: expandPath(m.config, root),
+      tokenCache: expandPath(m.token_cache, root),
+      color: m.color,
+    };
+  }
+  return out.google || out.microsoft ? out : undefined;
 }
 
 interface FoundConfig {
@@ -158,6 +238,7 @@ function normalize(raw: Partial<RawConfig>, root: string, loaded: boolean): Conf
       Array.isArray(raw.resume_command) && raw.resume_command.length > 0
         ? raw.resume_command.map(String)
         : undefined,
+    calendars: normalizeCalendars(raw.calendars, root),
   };
 }
 

package/src/input/handleKey.ts

@@ -23,7 +23,7 @@ import {
   type TuiStore,
 } from "~/store/index";
 import type { Board, PriorityLevel } from "~/types";
-import { buildTimelineEntries } from "~/store/timeline";
+import { buildTimelineEntries, formatAgendaDay } from "~/store/timeline";
 import { buildVirtualItems } from "~/store/virtual-panel";
 import { jumpToKanban } from "~/ui/TimelineView";
 
@@ -247,9 +247,29 @@ function handleTimelineZone(
   openLater: (m: ModalKind) => void,
 ): void {
   const ui = store.state.ui;
+
+  // Day navigation: page the Agenda to other days (tasks + calendar events).
+  // `[` previous, `]` next, `\` back to today. Handled first so they work
+  // regardless of arm/cursor state.
+  if (key.name === "[" || key.sequence === "[") {
+    store.shiftAgendaDay(-1);
+    store.flashBanner("info", `◀ ${formatAgendaDay(store.state.ui.agendaOffset, store.agendaDate())}`);
+    return;
+  }
+  if (key.name === "]" || key.sequence === "]") {
+    store.shiftAgendaDay(1);
+    store.flashBanner("info", `▶ ${formatAgendaDay(store.state.ui.agendaOffset, store.agendaDate())}`);
+    return;
+  }
+  if (key.name === "\\" || key.sequence === "\\") {
+    store.resetAgendaDay();
+    store.flashBanner("info", "Agenda → Today");
+    return;
+  }
+
   const entries = buildTimelineEntries(
     store.state.boards.map((b) => b.board),
-    isoToday(),
+    store.agendaDate(),
   );
   const target = entries[ui.row];
 

package/src/parser/markdown.ts

@@ -326,7 +326,7 @@ function extractBoardName(frontmatter: string, filepath: string): string {
   const m = frontmatter.match(/^name:\s*(.+?)\s*$/m);
   if (m) return m[1]!;
   const file = basename(filepath, extname(filepath));
-  // "Tasks - R3PLICA" → "R3PLICA"; otherwise use as-is.
+  // "Tasks - Work" → "Work"; otherwise use as-is.
   const dash = file.indexOf(" - ");
   return dash >= 0 ? file.slice(dash + 3) : file;
 }