tuiboard 0.8.2 → 0.8.5

package/.tuiboard/config.example.yaml

@@ -62,6 +62,15 @@ archive_column: Archive
 #   - "{cwd}"
 #   - "{sessionId}"
 
+# Optional: the command copied to your clipboard by `c` in the Agents zone — one
+# paste that cd's into the session's directory and resumes it, for when you want
+# to open the session yourself in a new tab/pane anywhere (no WezTerm needed).
+# The tokens {cwd} and {sessionId} are substituted. It's a plain string, so use
+# whatever chaining your shell wants. Default (works in bash/zsh/pwsh/cmd):
+#   copy_resume_command: 'cd "{cwd}" && claude --resume {sessionId}'
+# Nushell users typically want `;` instead of `&&`:
+# copy_resume_command: 'cd "{cwd}"; claude --resume {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

package/CHANGELOG.md

@@ -5,6 +5,72 @@ All notable changes to **tuiboard** are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.8.5] - 2026-08-31
+
+### Added
+- **`tuiboard summary` — JSON snapshot for status bars and scripts.** Totals, a
+  per-board breakdown, and `planner`: the same Today / Tomorrow / Overdue
+  aggregation the planner zone renders, built from `buildPlannerItems()` so a
+  bar widget and the dashboard can never disagree about what is due. `--pretty`
+  to read it, `--next N` to size (or drop) the per-board upcoming list.
+- **`tuiboard task` — headless mutations.** `done`, `undone`, `defer` and `add`
+  against a board file, matched **by title rather than index** so a task that
+  moved is a miss instead of the wrong task. `--dry-run` reports without
+  writing; an ambiguous title is refused rather than guessed at; exit 3 means
+  the board changed on disk since it was read.
+- **`undone` reopens a completed task**, dropping its `✅` date with the tick —
+  the exact inverse of `done`, and the same semantics as the TUI's Enter.
+- **`defer` moves the date the planner actually reads** (`scheduled`, else
+  `due`, else adds a `scheduled`), so the row really moves. Defaults to
+  tomorrow; `--days N` or `--to YYYY-MM-DD` for anything else, `--days 0` to
+  pull a task back to today.
+- **Planner entries in `summary` now report `done` and `doneDate`.** Today and
+  Tomorrow keep completed tasks — a day's plan is a record of the day — so
+  without this a consumer had no way to tell a ticked task from an open one.
+
+### Fixed
+- **Node's warnings no longer scribble on the dashboard.** OpenTUI registers one
+  `selection` listener per `<scrollbox>`, and a full dashboard keeps more than
+  ten alive (one per board column, plus planner, timeline and agents), tripping
+  Node's default `MaxListeners` cap of 10 — usually when `Tab` mounted a new
+  board's columns. The warning went to stderr, which is the alternate screen the
+  renderer believes it owns: two lines scrolled the buffer and every repaint
+  after that landed rows off, so the layout appeared to break on a keypress. The
+  cap is now sized for the real number of zones, and any remaining warning is
+  filed in `~/.cache/tuiboard/warnings.log` instead of on the screen.
+
+## [0.8.4] - 2026-07-31
+
+### Added
+- **Copy a session's resume command (`c` in the Agents zone).** Select a Claude
+  Code session and press `c` to copy a one-paste command that `cd`s into its
+  directory and resumes it — `cd "<cwd>" && claude --resume <id>` by default — so
+  you can drop it into any tab or pane, on any machine layout, without depending
+  on WezTerm (which `Enter` requires). The format is configurable via
+  `copy_resume_command` (tokens `{cwd}` / `{sessionId}`); Nushell users can swap
+  `&&` for `;`. The session detail view (`o`) now shows this exact command.
+
+### Fixed
+- **Modals now appear in zoom mode.** Opening a modal (new task, schedule, time
+  block, assign, edit, delete, search, new event…) while a zone was zoomed (`z`)
+  set the modal state but rendered nothing — the zoomed layout had no Agenda slot
+  to host it, so the dialog was invisible and you typed blind. The modal now
+  floats as a centered overlay on top of the zoomed view; closing it returns you
+  to the zoomed view exactly as you left it.
+
+## [0.8.3] - 2026-06-04
+
+### Added
+- **Boot splash.** Launching tuiboard now paints a `tuiboard` wordmark (FIGlet
+  "Rectangles", in the tool's light-yellow accent) the instant the process
+  starts, so the ~1s cold start (runtime + store build + first calendar/agents
+  read) isn't a blank terminal. The launcher animates the booting dots while the
+  dashboard process loads in parallel, then hands the screen over cleanly — no
+  startup time added. Set `TUIBOARD_NO_SPLASH=1` to disable; it also no-ops when
+  output isn't a TTY or the terminal is tiny.
+
 ## [0.8.2] - 2026-06-04
 
 ### Changed
@@ -163,6 +229,9 @@ First public release on npm. This entry captures the full feature set at launch.
 
 Built with [OpenTUI](https://opentui.com) + SolidJS on Bun.
 
+[0.8.5]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.5
+[0.8.4]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.4
+[0.8.3]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.3
 [0.8.2]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.2
 [0.8.1]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.1
 [0.8.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.0

package/README.md

@@ -147,6 +147,12 @@ archive_column: Archive
 # path, NOT a shell builtin or Windows App Execution Alias). Defaults to
 # opening a WezTerm tab with `claude --resume <id>`. For a custom layout:
 # resume_command: ["nu", "C:/Users/you/.config/tuiboard/code-resume.nu", "{cwd}", "{sessionId}"]
+
+# Optional: the command `c` copies to the clipboard in the Agents zone — one
+# paste that cd's into the session dir and resumes it, so you can open it
+# yourself in any tab/pane (no WezTerm needed). {cwd}/{sessionId} substituted.
+# Default: 'cd "{cwd}" && claude --resume {sessionId}'. Nushell users:
+# copy_resume_command: 'cd "{cwd}"; claude --resume {sessionId}'
 ```
 
 ## Zones
@@ -397,6 +403,15 @@ session (until the next terminal resize).
 | `j` / `k` | While armed: nudge the block ±15 min |
 | `+` / `-` | While armed: resize the block's end ±15 min |
 
+### Agents (agents zone)
+
+| Key | Action |
+|---|---|
+| `j` / `k` | Move the cursor down / up the session list |
+| `Enter` | Open (resume) the selected session in a new WezTerm tab |
+| `c` | Copy a one-paste `cd … && claude --resume <id>` command for the selected session — drop it into any tab/pane to land in the right dir and resume (no WezTerm needed; format is `copy_resume_command`) |
+| `o` | Session detail (cwd, branch, last prompts, resume command) |
+
 ### Task actions (work in board, planner, AND timeline zones)
 
 | Key | Action |
@@ -433,10 +448,63 @@ session (until the next terminal resize).
 | `?` | Help modal with the full reference |
 | `q` · `Ctrl-C` | Quit |
 
+## Headless commands
+
+Two subcommands run without the TUI, for status bars, widgets and scripts.
+Both reuse the same config loader and parser as the dashboard, so they can
+never disagree with it about what is on your board.
+
+### `tuiboard summary` — JSON snapshot
+
+```bash
+tuiboard summary                # compact JSON on stdout
+tuiboard summary --pretty       # indented, for reading
+tuiboard summary --next 8       # upcoming tasks per board (default 5, 0 = none)
+```
+
+Returns totals, a per-board breakdown, and `planner` — the same Today /
+Tomorrow / Overdue aggregation the planner zone renders, each entry carrying
+its title, board, column, bucket, priority, dates, time block, assignee, and
+whether it is already `done` (with `doneDate`). Today and Tomorrow keep
+completed tasks, as the panel does: a day's plan is a record of the day, not
+only of what is left.
+
+### `tuiboard task` — mutations
+
+```bash
+tuiboard task done   --board Personal --column Home --match "Bollette"
+tuiboard task undone --board Personal --column Home --match "Bollette"
+tuiboard task defer  --board Personal --column Home --match "Bollette" [--days N | --to YYYY-MM-DD]
+tuiboard task add    --board Personal --column Home --text "Nuova task 🔺 ⏳ 2026-09-01"
+```
+
+`--dry-run` reports what would change and writes nothing. `defer` defaults to
+one day and moves the date the planner actually reads (`scheduled`, else
+`due`, else adds a `scheduled`), so the row really moves; `--days 0` pulls a
+task back to today.
+
+Tasks are matched **by title, not by index**: a position is only valid inside
+one render pass, and a widget polling every couple of minutes holds a stale
+snapshot — matching on text makes a moved task a miss rather than a mistake.
+An ambiguous match is refused rather than guessed at.
+
+| Exit | Meaning |
+|---|---|
+| `0` | Done (including "already done" / "already open" — both are no-ops) |
+| `1` | No match, ambiguous match, or unknown board/column |
+| `2` | Bad arguments |
+| `3` | The board changed on disk since it was read — refresh and retry |
+
+Exit 3 is the mtime watermark: a write is refused rather than allowed to
+clobber an edit made in the TUI or another editor in the meantime.
+
 ## Status
 
 See [CHANGELOG.md](CHANGELOG.md) for the full release history.
 
+- **v0.8** — write to Google Calendar from the Agenda: create, edit, and delete
+  events (opt-in), set their date and time in the modal, plus all-day events in
+  the top strip, consistent `t`/`m` date shortcuts, and a boot splash.
 - **v0.7** — configurable zones: turn the planner, agenda, or agents view off
   (or start it collapsed) via the `zones:` config, so tuiboard can be a pure
   kanban, kanban + calendar, or any mix.
@@ -448,6 +516,15 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release history.
   responsive layout. Tested on Windows with WezTerm; Linux/macOS should
   work via the same OpenTUI binaries (untested).
 
+## Contributing
+
+Contributions are welcome — bugs, docs, fixes, features, or just trying it on a
+platform I haven't tested. See [CONTRIBUTING.md](CONTRIBUTING.md) for setup, the
+project layout, and the checks to run, and the [good first issues][gfi] for a
+place to start.
+
+[gfi]: https://github.com/NazzarenoGiannelli/tuiboard/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22
+
 ## License
 
 MIT — see [LICENSE](LICENSE).

package/bin/tuiboard.ts

@@ -11,10 +11,15 @@
  * any CLI args, and inherit stdio so the TUI keeps the real terminal.
  */
 
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import pkg from "../package.json";
+import { animateBooting, printSplash, showCursor } from "../src/ui/splash.ts";
+
 const here = dirname(fileURLToPath(import.meta.url));
 const appPath = join(here, "..", "src", "app.tsx");
 
@@ -24,12 +29,64 @@ if (process.argv[2] === "calendar-setup") {
   const { runCalendarSetup } = await import("../src/calendar/setup.ts");
   process.exit(await runCalendarSetup(process.argv.slice(3)));
 }
+if (process.argv[2] === "summary") {
+  const { runSummary } = await import("../src/cli/summary.ts");
+  process.exit(await runSummary(process.argv.slice(3)));
+}
+if (process.argv[2] === "task") {
+  const { runTask } = await import("../src/cli/task.ts");
+  process.exit(await runTask(process.argv.slice(3)));
+}
 const preload = fileURLToPath(import.meta.resolve("@opentui/solid/preload"));
 
-const result = spawnSync(
+// Paint the splash from the (already-running) launcher and animate its booting
+// dots while the child cold-starts. Using `spawn` (not `spawnSync`) keeps this
+// process's event loop free to run the animation. We MUST stop animating the
+// instant before the child enters OpenTUI's alternate screen, or our writes
+// would land on the dashboard — so the child drops a "ready" flag file just
+// before render() and we poll for it.
+printSplash(pkg.version);
+const stopAnim = animateBooting(pkg.version);
+// The splash hides the cursor; make sure it comes back when the launcher exits
+// (after the child has torn down), so the shell is never left cursor-less.
+process.on("exit", showCursor);
+const readyFlag = join(tmpdir(), `tuiboard-ready-${process.pid}`);
+try { rmSync(readyFlag, { force: true }); } catch { /* ignore */ }
+
+let poll: ReturnType<typeof setInterval> | undefined;
+let safety: ReturnType<typeof setTimeout> | undefined;
+let stopped = false;
+const stopSplash = () => {
+  if (stopped) return;
+  stopped = true;
+  stopAnim();
+  if (poll) clearInterval(poll);
+  if (safety) clearTimeout(safety);
+  try { rmSync(readyFlag, { force: true }); } catch { /* ignore */ }
+};
+poll = setInterval(() => { if (existsSync(readyFlag)) stopSplash(); }, 30);
+safety = setTimeout(stopSplash, 4000); // fallback if the child never signals
+
+// Ctrl-C reaches the child directly (same process group); it cleans up and
+// exits, then we mirror its code below. Ignore the signal here so the launcher
+// doesn't die first and orphan the child mid-teardown.
+process.on("SIGINT", () => {});
+process.on("SIGTERM", () => {});
+
+const child = spawn(
   process.execPath, // the bun binary running this script
   ["--preload", preload, appPath, ...process.argv.slice(2)],
-  { stdio: "inherit" },
+  {
+    stdio: "inherit",
+    env: { ...process.env, TUIBOARD_SPLASH_DONE: "1", TUIBOARD_READY_FLAG: readyFlag },
+  },
 );
-
-process.exit(result.status ?? 1);
+child.on("exit", (code, signal) => {
+  stopSplash();
+  process.exit(code ?? (signal ? 1 : 0));
+});
+child.on("error", (err) => {
+  stopSplash();
+  console.error(String(err));
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuiboard",
-  "version": "0.8.2",
+  "version": "0.8.5",
   "description": "Terminal kanban for markdown task boards, with optional Today/Tomorrow planner, 24h agenda + calendar overlay, and a live Claude Code agent view. Use only the panels you want.",
   "type": "module",
   "license": "MIT",
@@ -32,6 +32,7 @@
     "tb": "./bin/tuiboard.ts"
   },
   "files": [
+    "tsconfig.json",
     "src/",
     "bin/",
     ".tuiboard/config.example.yaml",
@@ -47,6 +48,7 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "agents:check": "bun run src/scripts/agents-check.ts",
+    "summary": "bun run src/cli/summary.ts",
     "prepublishOnly": "bun run typecheck && bun test"
   },
   "dependencies": {

package/src/app.tsx

@@ -12,6 +12,15 @@
  * root layout component changes.
  */
 
+// FIRST import on purpose: paints the boot splash before the heavy imports
+// (OpenTUI) and the ~600ms store build below run. See ui/splash-boot.ts.
+import "~/ui/splash-boot";
+
+import { EventEmitter } from "node:events";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
 import { createMemo } from "solid-js";
 import { render, useKeyboard } from "@opentui/solid";
 
@@ -31,6 +40,35 @@ import { Dashboard } from "~/views/Dashboard";
 import { TimelineOnly } from "~/views/TimelineOnly";
 import { AgentsOnly } from "~/views/AgentsOnly";
 
+// ─── Keep Node's own output off the screen ──────────────────────────────────
+//
+// OpenTUI registers one "selection" listener on the renderer per <scrollbox>,
+// and a dashboard keeps more than ten alive at once: one per board column,
+// plus planner, timeline and agents. That is a legitimate count, not a leak,
+// but it trips Node's default MaxListeners cap of 10 — and switching board
+// with Tab crosses the threshold as the new columns mount.
+EventEmitter.defaultMaxListeners = 64;
+
+// Whatever still warns must never reach the terminal. Node writes warnings to
+// stderr, which here means straight onto the alternate screen the renderer
+// believes it owns: the two extra lines scroll the buffer, and from then on
+// every absolutely-positioned repaint lands a couple of rows off — the layout
+// appears to "break" on the next keypress. Removing the default handler stops
+// Node printing them; ours files them where they can still be read.
+process.removeAllListeners("warning");
+process.on("warning", (w: Error) => {
+  try {
+    const dir = join(homedir(), ".cache", "tuiboard");
+    mkdirSync(dir, { recursive: true });
+    appendFileSync(
+      join(dir, "warnings.log"),
+      `${new Date().toISOString()} ${w.name}: ${w.message}\n${w.stack ?? ""}\n`,
+    );
+  } catch {
+    // A log we cannot write is not worth losing the screen over.
+  }
+});
+
 // ─── Bootstrap ──────────────────────────────────────────────────────────────
 
 const config = loadConfig();
@@ -150,4 +188,18 @@ function App() {
   );
 }
 
+// Signal the launcher (if we were spawned by the `tuiboard` bin) that we're
+// about to take the screen, so it stops animating the splash a beat before
+// OpenTUI enters the alternate buffer — otherwise its writes would land on the
+// dashboard. The short delay gives the launcher's poll a cycle to notice.
+if (process.env.TUIBOARD_READY_FLAG) {
+  try {
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(process.env.TUIBOARD_READY_FLAG, "1");
+    await new Promise((r) => setTimeout(r, 70));
+  } catch {
+    // Cosmetic only — never block startup on the splash handshake.
+  }
+}
+
 await render(() => <App />, { useMouse: true });

package/src/cli/headless.test.ts

@@ -0,0 +1,202 @@
+/**
+ * The headless CLI — `tuiboard task` and `tuiboard summary`.
+ *
+ * These are the only commands that write to the user's real board files from
+ * outside the TUI (a bar widget, a cron job), so they are tested against a
+ * real board on disk rather than a parsed fixture: the round trip through
+ * parse → mutate → serialize → write is exactly what can lose data.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { ConflictError, statMtime, writeBoardFile } from "~/io/writer";
+import { buildSummary } from "./summary";
+import { runTask } from "./task";
+
+const BOARD = `---
+
+kanban-plugin: board
+
+---
+
+## Home
+- [ ] Bollette ⏳ 2026-08-31
+- [x] Spesa ⏳ 2026-08-31 ✅ 2026-08-31
+- [ ] Chiamare idraulico 📅 2026-08-31
+- [ ] Cambiare gomme
+- [ ] Ambiguo uno
+- [ ] Ambiguo due
+`;
+
+let dir: string;
+let boardPath: string;
+let configPath: string;
+let previousConfig: string | undefined;
+
+/** Days from today as YYYY-MM-DD, in local time — matches the CLI's own clock. */
+function iso(offsetDays: number): string {
+  const d = new Date();
+  d.setDate(d.getDate() + offsetDays);
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+function board(): string {
+  return readFileSync(boardPath, "utf-8");
+}
+
+function line(title: string): string {
+  const hit = board()
+    .split("\n")
+    .find((l) => l.includes(title));
+  if (!hit) throw new Error(`no line matching "${title}" in board`);
+  return hit;
+}
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "tuiboard-cli-"));
+  boardPath = join(dir, "Board.md");
+  configPath = join(dir, "config.yaml");
+  writeFileSync(boardPath, BOARD, "utf-8");
+  writeFileSync(configPath, `boards:\n  - path: ${boardPath}\n    name: Test\n`, "utf-8");
+  previousConfig = process.env.TUIBOARD_CONFIG;
+  process.env.TUIBOARD_CONFIG = configPath;
+});
+
+afterEach(() => {
+  if (previousConfig === undefined) delete process.env.TUIBOARD_CONFIG;
+  else process.env.TUIBOARD_CONFIG = previousConfig;
+  rmSync(dir, { recursive: true, force: true });
+});
+
+const args = (...rest: string[]) => ["--board", "Test", "--column", "Home", ...rest];
+
+describe("tuiboard task done", () => {
+  it("ticks the task and stamps today's completion date", async () => {
+    expect(await runTask(["done", ...args("--match", "Bollette")])).toBe(0);
+    expect(line("Bollette")).toBe(`- [x] Bollette ⏳ 2026-08-31 ✅ ${iso(0)}`);
+  });
+
+  it("leaves an already-done task untouched", async () => {
+    const before = line("Spesa");
+    expect(await runTask(["done", ...args("--match", "Spesa")])).toBe(0);
+    expect(line("Spesa")).toBe(before);
+  });
+});
+
+describe("tuiboard task undone", () => {
+  it("reopens a completed task and drops the completion date with it", async () => {
+    expect(await runTask(["undone", ...args("--match", "Spesa")])).toBe(0);
+    expect(line("Spesa")).toBe("- [ ] Spesa ⏳ 2026-08-31");
+  });
+
+  it("is the exact inverse of done — round trip restores the line", async () => {
+    const before = line("Bollette");
+    expect(await runTask(["done", ...args("--match", "Bollette")])).toBe(0);
+    expect(await runTask(["undone", ...args("--match", "Bollette")])).toBe(0);
+    expect(line("Bollette")).toBe(before);
+  });
+
+  it("leaves an already-open task untouched", async () => {
+    const before = line("Bollette");
+    expect(await runTask(["undone", ...args("--match", "Bollette")])).toBe(0);
+    expect(line("Bollette")).toBe(before);
+  });
+});
+
+describe("tuiboard task defer", () => {
+  it("moves `scheduled` when the task has one", async () => {
+    expect(await runTask(["defer", ...args("--match", "Bollette")])).toBe(0);
+    expect(line("Bollette")).toBe(`- [ ] Bollette ⏳ ${iso(1)}`);
+  });
+
+  it("moves `due` when that is the only date — the field the planner reads", async () => {
+    expect(await runTask(["defer", ...args("--match", "idraulico")])).toBe(0);
+    expect(line("idraulico")).toBe(`- [ ] Chiamare idraulico 📅 ${iso(1)}`);
+  });
+
+  it("schedules an undated task, which is what puts it on the agenda", async () => {
+    expect(await runTask(["defer", ...args("--match", "gomme")])).toBe(0);
+    expect(line("gomme")).toBe(`- [ ] Cambiare gomme ⏳ ${iso(1)}`);
+  });
+
+  it("--days 0 pulls a task back to today", async () => {
+    expect(await runTask(["defer", ...args("--match", "Bollette", "--days", "0")])).toBe(0);
+    expect(line("Bollette")).toBe(`- [ ] Bollette ⏳ ${iso(0)}`);
+  });
+
+  it("--to takes an explicit date", async () => {
+    expect(await runTask(["defer", ...args("--match", "Bollette", "--to", "2027-01-15")])).toBe(0);
+    expect(line("Bollette")).toBe("- [ ] Bollette ⏳ 2027-01-15");
+  });
+
+  it("rejects a malformed --to without touching the board", async () => {
+    const before = board();
+    expect(await runTask(["defer", ...args("--match", "Bollette", "--to", "15/01/2027")])).toBe(2);
+    expect(board()).toBe(before);
+  });
+});
+
+describe("tuiboard task — refusing to guess", () => {
+  it("writes nothing when the match is ambiguous", async () => {
+    const before = board();
+    expect(await runTask(["done", ...args("--match", "Ambiguo")])).toBe(1);
+    expect(board()).toBe(before);
+  });
+
+  it("writes nothing when nothing matches", async () => {
+    const before = board();
+    expect(await runTask(["done", ...args("--match", "inesistente")])).toBe(1);
+    expect(board()).toBe(before);
+  });
+
+  it("--dry-run reports success and leaves the file alone", async () => {
+    const before = board();
+    expect(await runTask(["done", ...args("--match", "Bollette", "--dry-run")])).toBe(0);
+    expect(board()).toBe(before);
+  });
+
+  it("refuses the write when the board moved on since it was read", () => {
+    // What `runTask` maps to exit 3. Driven through the writer directly: the
+    // race it guards against — the file changing between the read and the
+    // write — cannot be staged from outside the function that spans it.
+    const stale = statMtime(boardPath);
+    const past = new Date(Date.now() - 60_000);
+    utimesSync(boardPath, past, past);
+    const before = board();
+    expect(() => writeBoardFile(boardPath, "clobbered", { expectedMtimeMs: stale }))
+      .toThrow(ConflictError);
+    expect(board()).toBe(before);
+  });
+});
+
+describe("tuiboard summary — planner entries", () => {
+  it("reports whether a Today entry is already ticked", async () => {
+    // The board's dates are fixed, so the summary is asked for that same day.
+    const s = buildSummary({ next: 0, today: "2026-08-31" });
+    const today = s.planner.today;
+    const bollette = today.find((e) => e.title === "Bollette");
+    const spesa = today.find((e) => e.title === "Spesa");
+
+    expect(bollette?.done).toBe(false);
+    expect(bollette?.doneDate).toBeUndefined();
+    expect(spesa?.done).toBe(true);
+    expect(spesa?.doneDate).toBe("2026-08-31");
+  });
+
+  it("follows a task through done and back", async () => {
+    await runTask(["done", ...args("--match", "Bollette")]);
+    const done = buildSummary({ next: 0, today: "2026-08-31" })
+      .planner.today.find((e) => e.title === "Bollette");
+    expect(done?.done).toBe(true);
+
+    await runTask(["undone", ...args("--match", "Bollette")]);
+    const reopened = buildSummary({ next: 0, today: "2026-08-31" })
+      .planner.today.find((e) => e.title === "Bollette");
+    expect(reopened?.done).toBe(false);
+    expect(reopened?.doneDate).toBeUndefined();
+  });
+});