tuiboard 0.8.5 → 0.9.1

package/src/ui/Modal.tsx

@@ -11,7 +11,7 @@
  * checks `ui.modal` first and bails if set (only Escape passes through).
  */
 
-import { For, Show, createMemo, createSignal } from "solid-js";
+import { For, Show, createContext, createMemo, createSignal, useContext } from "solid-js";
 
 import { isTask } from "~/parser/markdown";
 import {
@@ -29,14 +29,23 @@ import type { PriorityLevel, TimeBlock } from "~/types";
  *  slot (the Dashboard renders it there while a modal is open) with no reflow. */
 const MODAL_WIDTH = AGENDA_WIDTH;
 
+/**
+ * Whether the dialog is standing in for a whole pane (single-pane) or sitting
+ * in the Agenda's slot (four-zone). It decides how wide the dialog may be, and
+ * only ModalLayer is in a position to know.
+ */
+const SinglePaneContext = createContext<() => boolean>(() => false);
+
 export function ModalLayer(props: { store: TuiStore }) {
   const modal = createMemo(() => props.store.state.ui.modal);
   return (
+    <SinglePaneContext.Provider value={() => props.store.singlePane()}>
     <Show when={modal()}>
       {/* Each modal's DialogShell IS the panel box (border + title + slot
           dimensions), so it drops into the Agenda's slot directly. */}
       <ModalRouter store={props.store} modal={modal()!} />
     </Show>
+    </SinglePaneContext.Provider>
   );
 }
 
@@ -55,6 +64,7 @@ function ModalRouter(props: { store: TuiStore; modal: NonNullable<TuiStore["stat
     case "event-edit": return <EventEditModal store={props.store} />;
     case "confirm-delete-event": return <ConfirmDeleteEventModal store={props.store} />;
     case "search":   return <SearchModal store={props.store} />;
+    case "board-new": return <BoardNewModal store={props.store} />;
     case "help":     return <HelpModal store={props.store} />;
   }
 }
@@ -68,7 +78,155 @@ interface DialogShellProps {
   width?: number;
 }
 
+// ─── New board ───────────────────────────────────────────────────────────────
+
+/**
+ * Onboarding and the `+` button are the same screen, differing only in title
+ * and in whether Escape works: on first run there is nothing behind it.
+ *
+ * Deliberately thin. Every step that touches the disk calls into
+ * `src/boards/`, which is also what `tuiboard board add` calls, so the two
+ * entry points cannot drift apart.
+ */
+function BoardNewModal(props: { store: TuiStore }) {
+  const w = createMemo(() => props.store.state.ui.boardNew);
+
+  const title = createMemo(() =>
+    w()?.mandatory ? "Welcome to tuiboard" : "New board",
+  );
+
+  const hint = createMemo(() => {
+    const b = w();
+    if (!b) return "";
+    if (b.step === "mode") return "j/k choose · Enter confirm" + (b.mandatory ? "" : " · Esc cancel");
+    if (b.step === "pick") return "j/k move · Space tick · Enter adopt · Esc back";
+    return "Enter confirm" + (b.mandatory ? "" : " · Esc cancel");
+  });
+
+  return (
+    <DialogShell title={title()} hint={hint()} width={MODAL_WIDTH}>
+      <Show when={w()}>
+        {(b: () => NonNullable<ReturnType<typeof w>>) => (
+          <box style={{ flexDirection: "column" }}>
+            <Show when={b().mandatory && b().step === "mode"}>
+              <text>
+                <span style={{ fg: T.textDim }}>
+                  No boards configured yet. Boards are plain markdown files.
+                </span>
+              </text>
+              <text> </text>
+            </Show>
+
+            {/* Step 1 — which way through */}
+            <Show when={b().step === "mode"}>
+              <For each={[
+                { key: "create", label: "Create a new board", desc: "a new markdown file" },
+                { key: "adopt", label: "Use files I already have", desc: "scan a folder" },
+              ]}>
+                {(opt, i) => (
+                  <text>
+                    <span style={{ fg: b().sel === i() ? T.accent : T.text }}>
+                      {b().sel === i() ? "▶ " : "  "}{opt.label}
+                    </span>
+                    <span style={{ fg: T.textDim }}>{"  — " + opt.desc}</span>
+                  </text>
+                )}
+              </For>
+            </Show>
+
+            {/* Step 2a — name, then columns */}
+            <Show when={b().step === "name"}>
+              <text><span style={{ fg: T.textDim }}>Board name</span></text>
+              <input
+                focused
+                value=""
+                onSubmit={((v: string) => props.store.boardNewSubmitText(v)) as any}
+              />
+              <text>
+                <span style={{ fg: T.textDim }}>{"It will live in " + b().dir}</span>
+              </text>
+            </Show>
+
+            <Show when={b().step === "columns"}>
+              <text><span style={{ fg: T.textDim }}>Columns, comma separated</span></text>
+              <input
+                focused
+                value={b().columns}
+                onSubmit={((v: string) => props.store.boardNewSubmitText(v)) as any}
+              />
+              <text>
+                <span style={{ fg: T.textDim }}>{"Creating " + b().name + ".md"}</span>
+              </text>
+            </Show>
+
+            {/* Step 2b — a folder, then what was found in it */}
+            <Show when={b().step === "dir"}>
+              <text><span style={{ fg: T.textDim }}>Folder to scan</span></text>
+              <input
+                focused
+                value={b().dir}
+                onSubmit={((v: string) => props.store.boardNewSubmitText(v)) as any}
+              />
+            </Show>
+
+            <Show when={b().step === "pick"}>
+              <text>
+                <span style={{ fg: T.textDim }}>
+                  {b().candidates.length + " board file(s) in " + b().dir}
+                </span>
+              </text>
+              <For each={b().candidates}>
+                {(c, i) => (
+                  <text>
+                    <span style={{ fg: b().sel === i() ? T.accent : T.text }}>
+                      {b().sel === i() ? "▶ " : "  "}
+                      {c.alreadyInConfig ? "· " : b().ticked.includes(i()) ? "✓ " : "  "}
+                      {c.suggestedName}
+                    </span>
+                    <span style={{ fg: T.textDim }}>
+                      {"  " + c.taskCount + (c.taskCount === 1 ? " task" : " tasks")
+                        + (c.alreadyInConfig ? " · already open" : "")}
+                    </span>
+                  </text>
+                )}
+              </For>
+            </Show>
+
+            <Show when={b().error}>
+              <text> </text>
+              <text><span style={{ fg: T.overdue }}>{b().error}</span></text>
+            </Show>
+          </box>
+        )}
+      </Show>
+    </DialogShell>
+  );
+}
+
+/**
+ * How wide the dialog may be.
+ *
+ * In the four-zone layout it takes the Agenda's slot and must match it to the
+ * cell, or the whole dashboard shifts when a modal opens — that invariant is
+ * why the requested width used to be ignored outright. In single-pane the
+ * dialog takes a whole pane's place instead, so there it can use what the
+ * terminal actually offers: the keyboard reference asks for 92 columns and is
+ * unreadable squeezed into 50, while a 60-column strip needs it to shrink
+ * rather than overflow.
+ */
+function dialogWidth(singlePane: boolean): number {
+  if (!singlePane) return MODAL_WIDTH;
+  // Standing in for a pane means behaving like one: take the strip. A dialog
+  // that keeps its slot-sized box while the rest of the screen sits empty
+  // reads as a window that failed to open, not as a panel.
+  const terminal = process.stdout.columns ?? 80;
+  return Math.max(20, terminal - 4);
+}
+
 function DialogShell(props: DialogShellProps) {
+  const singlePane = useContext(SinglePaneContext);
+  const width = () => dialogWidth(singlePane());
+  // `width` survives as the four-zone hint it always was; single-pane fills.
   void props.width;
   return (
     <box
@@ -78,9 +236,12 @@ function DialogShell(props: DialogShellProps) {
         // slot at the exact same size and the dashboard doesn't shift when a
         // modal opens. The title rides in the top border like the columns/zones.
         flexDirection: "column",
-        width: MODAL_WIDTH,
-        minWidth: MODAL_WIDTH,
-        flexGrow: 0,
+        width: width(),
+        minWidth: Math.min(MODAL_WIDTH, width()),
+        // In the Agenda's slot the box must not grow, or the dashboard shifts.
+        // Filling a pane, it must — in both axes, like the zone it replaces.
+        flexGrow: singlePane() ? 1 : 0,
+        height: singlePane() ? "100%" : undefined,
         marginLeft: 1,
         backgroundColor: T.panelBgActive,
         border: true,
@@ -805,6 +966,8 @@ function HelpModal(props: { store: TuiStore }) {
         <span style={{ fg: T.textDim }}>{"Navigation\n"}</span>
         <span style={{ fg: T.text }}>{"  h j k l  ←↑↓→     Move cursor inside the active zone\n"}</span>
         <span style={{ fg: T.text }}>{"  Tab               Next board (kanban zone)\n"}</span>
+        <span style={{ fg: T.text }}>{"  +                 New board — create one, or adopt files you have\n"}</span>
+        <span style={{ fg: T.text }}>{"  z                 Focus one pane (automatic below 100 columns)\n"}</span>
         <span style={{ fg: T.text }}>{"  1..9              Jump to board N\n"}</span>
         <span style={{ fg: T.text }}>{"  v                 Toggle Today/Tomorrow planner panel focus\n"}</span>
         <span style={{ fg: T.text }}>{"  Shift-Tab         Cycle active zone (planner → board → timeline → agents)\n"}</span>

package/src/ui/PlannerPanel.tsx

@@ -40,7 +40,7 @@ export function PlannerPanel(props: { store: TuiStore }) {
   const groups = createMemo(() => groupPlannerItems(items()));
   const isActive = createMemo(() => props.store.state.ui.activeZone === "planner");
   const isZoomed = createMemo(
-    () => props.store.state.ui.zoomed && props.store.state.ui.activeZone === "planner",
+    () => props.store.singlePane() && props.store.state.ui.activeZone === "planner",
   );
   const cursorRow = createMemo(() => props.store.state.ui.row);
   let scrollBoxRef: ScrollBoxLike | undefined;

package/src/ui/pane-ring.ts

@@ -0,0 +1,73 @@
+/**
+ * The single-pane ring.
+ *
+ * When only one pane fits on screen, the zones stop being a layout — left and
+ * right no longer mean anything geometric — and become a sequence. This module
+ * builds that sequence and steps through it.
+ *
+ * The board is not one stop but many: in single-pane it renders a single
+ * column at full width, so each drawn column is its own pane. The result reads
+ * planner → column → column → … → agenda → agents, and closes into a ring.
+ *
+ * Pure: no store, no renderer, no terminal. The caller decides which zones are
+ * enabled and which columns are drawn — this only decides what comes next.
+ */
+
+export type RingZone = "planner" | "timeline" | "agents";
+
+export type Pane =
+  | { kind: "zone"; zone: RingZone }
+  | { kind: "column"; index: number };
+
+export interface RingInput {
+  /** Which zones the config enables. `board` is implied by renderedColumns. */
+  enabledZones: Record<"planner" | "board" | "timeline" | "agents", boolean>;
+  /**
+   * Board column indexes actually drawn, in order. Hidden columns (Done,
+   * Archive) must already be filtered out by the caller: a pane you cannot
+   * see is a dead end to step onto.
+   */
+  renderedColumns: readonly number[];
+}
+
+export function buildRing({ enabledZones, renderedColumns }: RingInput): Pane[] {
+  const ring: Pane[] = [];
+  if (enabledZones.planner) ring.push({ kind: "zone", zone: "planner" });
+  if (enabledZones.board) {
+    for (const index of renderedColumns) ring.push({ kind: "column", index });
+  }
+  if (enabledZones.timeline) ring.push({ kind: "zone", zone: "timeline" });
+  if (enabledZones.agents) ring.push({ kind: "zone", zone: "agents" });
+  return ring;
+}
+
+/**
+ * The next pane in `delta`'s direction, wrapping at both ends.
+ *
+ * A ring of one returns itself: stepping should feel like nothing happened,
+ * not like a wrap. If `current` is no longer in the ring — a column removed by
+ * a filter change or an external edit — the first pane is returned rather than
+ * something unrenderable.
+ */
+export function stepRing(ring: readonly Pane[], current: Pane, delta: 1 | -1): Pane {
+  if (ring.length === 0) return current;
+  if (ring.length === 1) return ring[0]!;
+
+  const at = ring.findIndex((p) => samePane(p, current));
+  if (at < 0) return ring[0]!;
+
+  const next = (at + delta + ring.length) % ring.length;
+  return ring[next]!;
+}
+
+export function samePane(a: Pane, b: Pane): boolean {
+  if (a.kind === "zone" && b.kind === "zone") return a.zone === b.zone;
+  if (a.kind === "column" && b.kind === "column") return a.index === b.index;
+  return false;
+}
+
+/** Where the current pane sits in the ring, for the position indicator. */
+export function ringPosition(ring: readonly Pane[], current: Pane): { at: number; of: number } {
+  const at = ring.findIndex((p) => samePane(p, current));
+  return { at: at < 0 ? 0 : at, of: ring.length };
+}

package/src/views/BoardOnly.tsx

@@ -18,16 +18,17 @@ import type { TuiStore } from "~/store/index";
 
 export function BoardOnly(props: { store: TuiStore }) {
   const ui = () => props.store.state.ui;
+  const singlePane = () => props.store.singlePane();
   const activeBoard = createMemo(
     () => props.store.state.boards[ui().activeBoardIndex]?.board,
   );
 
   return (
     <box style={{ flexDirection: "row", flexGrow: 1 }}>
-      <Show when={!ui().zoomed || ui().activeZone === "planner"}>
+      <Show when={!singlePane() || ui().activeZone === "planner"}>
         <PlannerPanel store={props.store} />
       </Show>
-      <Show when={(!ui().zoomed || ui().activeZone !== "planner") && activeBoard()}>
+      <Show when={(!singlePane() || ui().activeZone !== "planner") && activeBoard()}>
         <BoardView store={props.store} board={activeBoard()!} />
       </Show>
     </box>

package/src/views/Dashboard.tsx

@@ -38,7 +38,7 @@ export function Dashboard(props: { store: TuiStore }) {
 
   return (
     <Show
-      when={ui().zoomed}
+      when={props.store.singlePane()}
       fallback={<FourZoneLayout store={props.store} />}
     >
       <ZoomedLayout store={props.store} />
@@ -55,17 +55,19 @@ export function Dashboard(props: { store: TuiStore }) {
  * zone of the normal layout and BoardOnly already respects ui.zoomed
  * to render only the active panel between them.
  *
- * Modals: the normal layout drops them into the Agenda's slot, which doesn't
- * exist while zoomed — so here the modal floats as a centered absolute overlay
- * on top of the zoomed view. The user stays zoomed; close the modal and the
- * zoomed view is exactly as they left it (no exit-zoom / re-zoom flip).
+ * Modals take the pane's place, exactly as the four-zone layout drops them
+ * into the Agenda's slot: with one zone filling the screen, that zone IS the
+ * slot. They used to float as an absolute overlay, which had nothing to paint
+ * over — the theme leaves panel backgrounds transparent so the terminal shows
+ * through — so the dialog's text interleaved with the pane underneath and both
+ * became unreadable. Closing returns to the pane exactly as it was.
  */
 function ZoomedLayout(props: { store: TuiStore }) {
   const ui = () => props.store.state.ui;
   const zone = () => ui().activeZone;
 
   return (
-    <>
+    <Show when={ui().modal} fallback={
       <Show when={zone() === "timeline"} fallback={
         <Show when={zone() === "agents"} fallback={<BoardOnly store={props.store} />}>
           <AgentsOnly store={props.store} />
@@ -73,27 +75,9 @@ function ZoomedLayout(props: { store: TuiStore }) {
       }>
         <TimelineOnly store={props.store} />
       </Show>
-      {/* Modal overlay — only while zoomed AND a modal is open. Absolute + high
-          zIndex so it paints over the zoomed view; centered; transparent
-          backdrop so the board stays visible behind the (opaque) modal panel. */}
-      <Show when={ui().modal}>
-        <box
-          style={{
-            position: "absolute",
-            top: 0,
-            left: 0,
-            right: 0,
-            bottom: 0,
-            zIndex: 100,
-            flexDirection: "column",
-            alignItems: "center",
-            justifyContent: "center",
-          }}
-        >
-          <ModalLayer store={props.store} />
-        </box>
-      </Show>
-    </>
+    }>
+      <ModalLayer store={props.store} />
+    </Show>
   );
 }
 

package/src/cli/args.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { parseArgs, type ViewKind } from "./args";
-
-describe("parseArgs", () => {
-  it("returns view=undefined when no flag is present", () => {
-    expect(parseArgs([])).toEqual({ view: undefined });
-    expect(parseArgs(["bun", "src/app.tsx"])).toEqual({ view: undefined });
-  });
-
-  it("parses --view=board", () => {
-    expect(parseArgs(["--view=board"])).toEqual({ view: "board" });
-  });
-
-  it("parses --view=timeline", () => {
-    expect(parseArgs(["--view=timeline"])).toEqual({ view: "timeline" });
-  });
-
-  it("parses --view=agents", () => {
-    expect(parseArgs(["--view=agents"])).toEqual({ view: "agents" });
-  });
-
-  it("parses --view <value> with space separator", () => {
-    expect(parseArgs(["--view", "board"])).toEqual({ view: "board" });
-  });
-
-  it("returns view=undefined for unknown view value (with warning to stderr)", () => {
-    const result = parseArgs(["--view=garbage"]);
-    expect(result.view).toBeUndefined();
-  });
-
-  it("ignores other flags", () => {
-    expect(parseArgs(["--debug", "--view=board", "--something-else"])).toEqual({
-      view: "board",
-    });
-  });
-});
-
-// Type-level assertion: ensure ViewKind covers exactly the four expected values.
-const _viewKinds: ViewKind[] = ["board", "timeline", "agents"];
-void _viewKinds;

package/src/cli/headless.test.ts

@@ -1,202 +0,0 @@
-/**
- * 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();
-  });
-});

package/src/scripts/agents-check.ts

@@ -1,24 +0,0 @@
-/**
- * Smoke check for the agents store. Lists the first 10 sessions
- * discovered on this machine with status, display name, and short cwd.
- *
- * Usage: bun run agents:check
- */
-
-import { createAgentsStore } from "~/store/agents";
-
-const store = createAgentsStore();
-const all = store.sessions();
-const live = all.filter(
-  (s) => s.status === "live-busy" || s.status === "live-idle",
-);
-
-console.log(`Found ${all.length} sessions, ${live.length} live`);
-console.log("");
-for (const s of all.slice(0, 10)) {
-  console.log(
-    `  ${s.status.padEnd(10)}  ${s.displayName.padEnd(40)}  ${s.cwdShort}`,
-  );
-}
-
-await store.dispose();