tuiboard 0.8.5 → 0.9.0

package/src/ui/Modal.tsx

@@ -55,6 +55,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,6 +69,131 @@ 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>
+  );
+}
+
 function DialogShell(props: DialogShellProps) {
   void props.width;
   return (
@@ -805,6 +931,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} />

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();

package/src/scripts/parse-check.ts

@@ -1,124 +0,0 @@
-/**
- * CLI smoke-test for the markdown parser.
- *
- * Usage:
- *   bun run src/scripts/parse-check.ts                # uses config-discovered boards
- *   bun run src/scripts/parse-check.ts <file.md>...   # parses specific files
- *
- * Prints per-board summary: columns, task counts, metadata coverage,
- * diagnostics, and a sample of parsed tasks so we can eyeball correctness.
- */
-
-import { readFileSync } from "node:fs";
-import { loadConfig } from "~/config/loader";
-import { isTask, parseBoard } from "~/parser/markdown";
-import type { Task } from "~/types";
-
-const args = process.argv.slice(2);
-const files: string[] = [];
-
-if (args.length > 0) {
-  files.push(...args);
-} else {
-  const cfg = loadConfig();
-  if (!cfg.loaded) {
-    console.error(
-      `No .tuiboard/config.yaml found from ${cfg.root}. Using fallback scan of cwd.`,
-    );
-  }
-  if (cfg.boards.length === 0) {
-    console.error("No boards configured and none found via fallback scan.");
-    process.exit(1);
-  }
-  files.push(...cfg.boards.map((b) => b.path));
-}
-
-let totalTasks = 0;
-let totalDone = 0;
-let totalWithSched = 0;
-let totalWithTimeBlock = 0;
-let totalLegacyTimeBlock = 0;
-let totalWithPriority = 0;
-let totalDiagnostics = 0;
-
-for (const file of files) {
-  let content: string;
-  try {
-    content = readFileSync(file, "utf-8");
-  } catch (e) {
-    console.error(`✗ Cannot read ${file}: ${(e as Error).message}`);
-    continue;
-  }
-
-  const { board, diagnostics } = parseBoard(content, { filepath: file });
-  const tasks: Task[] = [];
-  for (const col of board.columns) {
-    for (const child of col.children) {
-      if (isTask(child)) tasks.push(child);
-    }
-  }
-  const done = tasks.filter((t) => t.done).length;
-  const withSched = tasks.filter((t) => t.scheduled).length;
-  const withTime = tasks.filter((t) => t.timeBlock).length;
-  const legacyTime = tasks.filter((t) => t.timeBlockSource === "legacy-prefix").length;
-  const withPrio = tasks.filter((t) => t.priority !== "none").length;
-
-  totalTasks += tasks.length;
-  totalDone += done;
-  totalWithSched += withSched;
-  totalWithTimeBlock += withTime;
-  totalLegacyTimeBlock += legacyTime;
-  totalWithPriority += withPrio;
-  totalDiagnostics += diagnostics.length;
-
-  console.log(`\n━━━ ${board.name} ━━━`);
-  console.log(`  file:         ${file}`);
-  console.log(`  frontmatter:  ${board.frontmatter ? "yes" : "no"}`);
-  console.log(`  trailer:      ${board.trailer ? "yes" : "no"}`);
-  console.log(`  columns:      ${board.columns.length} — ${board.columns.map((c) => c.name).join(" │ ")}`);
-  console.log(`  tasks total:  ${tasks.length}  (${done} done, ${tasks.length - done} open)`);
-  console.log(`  scheduled:    ${withSched}`);
-  console.log(`  time blocks:  ${withTime}  (${legacyTime} legacy prefix, ${withTime - legacyTime} ⌚)`);
-  console.log(`  priority:     ${withPrio}`);
-  console.log(`  diagnostics:  ${diagnostics.length}`);
-
-  // Show first 3 diagnostics
-  for (const d of diagnostics.slice(0, 3)) {
-    console.log(`    [L${d.line}] ${d.level}: ${d.message}`);
-  }
-  if (diagnostics.length > 3) console.log(`    … and ${diagnostics.length - 3} more`);
-
-  // Show first 5 parsed open tasks for eyeballing
-  const sample = tasks.filter((t) => !t.done).slice(0, 5);
-  if (sample.length > 0) {
-    console.log("\n  sample tasks:");
-    for (const t of sample) {
-      const tb = t.timeBlock
-        ? ` ⌚${fmtMin(t.timeBlock.startMin)}-${fmtMin(t.timeBlock.endMin)}`
-        : "";
-      const sched = t.scheduled ? ` ⏳${t.scheduled}` : "";
-      const prio = t.priority !== "none" ? ` [${t.priority}]` : "";
-      const assignee = t.assignee ? ` @${t.assignee}` : "";
-      const tags = t.tags.length ? ` ${t.tags.map((x) => "#" + x).join(" ")}` : "";
-      console.log(`    • ${truncate(t.displayTitle, 60)}${prio}${assignee}${sched}${tb}${tags}`);
-    }
-  }
-}
-
-console.log("\n━━━ TOTALS ━━━");
-console.log(`  files:        ${files.length}`);
-console.log(`  tasks:        ${totalTasks}  (${totalDone} done)`);
-console.log(`  scheduled:    ${totalWithSched}`);
-console.log(`  time blocks:  ${totalWithTimeBlock}  (${totalLegacyTimeBlock} legacy, ${totalWithTimeBlock - totalLegacyTimeBlock} ⌚)`);
-console.log(`  priority:     ${totalWithPriority}`);
-console.log(`  diagnostics:  ${totalDiagnostics}`);
-
-function fmtMin(m: number): string {
-  const h = Math.floor(m / 60).toString().padStart(2, "0");
-  const mm = (m % 60).toString().padStart(2, "0");
-  return `${h}:${mm}`;
-}
-
-function truncate(s: string, n: number): string {
-  return s.length <= n ? s : s.slice(0, n - 1) + "…";
-}