tuiboard 0.8.2 → 0.8.5

package/src/cli/summary.ts

@@ -0,0 +1,284 @@
+/**
+ * Headless JSON snapshot of the configured boards.
+ *
+ * Usage:
+ *   tuiboard summary              # compact JSON on stdout
+ *   tuiboard summary --pretty     # indented, for humans
+ *   tuiboard summary --next 8     # how many upcoming tasks per board (default 5)
+ *
+ * Written for status bars, widgets and scripts: no TUI, no OpenTUI preload.
+ * It deliberately reuses `loadConfig` and `parseBoard` rather than re-reading
+ * the markdown itself, so these numbers can never drift from what the
+ * dashboard shows — the parser stays the single source of truth.
+ */
+
+import { readFileSync } from "node:fs";
+
+import { isHiddenColumn, loadConfig } from "~/config/loader";
+import { isTask, parseBoard } from "~/parser/markdown";
+import { buildPlannerItems, type PlannerSection } from "~/store/planner-panel";
+import type { Board, PriorityLevel, Task } from "~/types";
+
+/** Lower sorts first, so "highest" leads an ascending sort. */
+const PRIORITY_RANK: Record<PriorityLevel, number> = {
+  highest: 0,
+  high: 1,
+  medium: 2,
+  low: 3,
+  lowest: 4,
+  none: 5,
+};
+
+export interface SummaryTask {
+  title: string;
+  board: string;
+  column: string;
+  priority: PriorityLevel;
+  due?: string;
+  scheduled?: string;
+  assignee?: string;
+  tags: string[];
+  /** Negative when overdue, 0 today, positive in the future, null when undated. */
+  daysUntil: number | null;
+}
+
+export interface SummaryColumn {
+  name: string;
+  open: number;
+}
+
+export interface SummaryBoard {
+  name: string;
+  path: string;
+  open: number;
+  done: number;
+  overdue: number;
+  today: number;
+  columns: SummaryColumn[];
+  next: SummaryTask[];
+  /** Parser complaints, so a malformed board is visible instead of silently empty. */
+  diagnostics: number;
+}
+
+/** One row of the Today/Tomorrow planner, flattened for consumers. */
+export interface PlannerEntry {
+  title: string;
+  board: string;
+  column: string;
+  /** "agenda" = time-blocked, "priority" = unscheduled priority, "rest" = everything else. */
+  bucket: string;
+  priority: PriorityLevel;
+  due?: string;
+  scheduled?: string;
+  timeBlock?: string;
+  assignee?: string;
+  /**
+   * Whether the task is already ticked. Today/Tomorrow keep completed tasks —
+   * the day's plan is a record of the day, not just of what is left — so a
+   * consumer that omits this renders a done task identically to an open one.
+   */
+  done: boolean;
+  /** Completion date, when the task carries one (✅ YYYY-MM-DD). */
+  doneDate?: string;
+}
+
+export interface Summary {
+  generatedAt: string;
+  totals: { open: number; done: number; overdue: number; today: number };
+  boards: SummaryBoard[];
+  /**
+   * The same Today/Tomorrow aggregation the TUI renders in its left column.
+   * Built with buildPlannerItems() rather than re-derived here, so a bar
+   * widget and the dashboard can never disagree about what is due.
+   */
+  planner: Record<PlannerSection, PlannerEntry[]>;
+}
+
+/** Local calendar date as YYYY-MM-DD — never UTC, or "today" flips at the wrong hour. */
+function localToday(now = new Date()): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+
+/** Whole days between two YYYY-MM-DD dates, midday-anchored to dodge DST. */
+function daysBetween(from: string, to: string): number {
+  const at = (iso: string) => {
+    const [y, m, d] = iso.split("-").map(Number);
+    return new Date(y!, (m ?? 1) - 1, d ?? 1, 12, 0, 0).getTime();
+  };
+  return Math.round((at(to) - at(from)) / 86_400_000);
+}
+
+/** "09:30-11:00" from minutes-since-midnight, or undefined when unblocked. */
+function formatTimeBlock(tb: Task["timeBlock"]): string | undefined {
+  if (!tb) return undefined;
+  const hhmm = (m: number) =>
+    String(Math.floor(m / 60)).padStart(2, "0") + ":" + String(m % 60).padStart(2, "0");
+  return hhmm(tb.startMin) + "-" + hhmm(tb.endMin);
+}
+
+/** The date a task is judged by: an explicit due date wins over a scheduled one. */
+function effectiveDate(task: Task): string | undefined {
+  return task.due ?? task.scheduled;
+}
+
+export function buildSummary(options: { next?: number; today?: string } = {}): Summary {
+  const nextCount = options.next ?? 5;
+  const today = options.today ?? localToday();
+  const config = loadConfig();
+
+  const boards: SummaryBoard[] = [];
+  const parsed: Board[] = [];
+  const totals = { open: 0, done: 0, overdue: 0, today: 0 };
+
+  for (const ref of config.boards) {
+    let content: string;
+    try {
+      content = readFileSync(ref.path, "utf-8");
+    } catch {
+      // A board listed in config but missing on disk is worth surfacing, not
+      // crashing over: a widget polling every 30s shouldn't die on a moved file.
+      boards.push({
+        name: ref.name ?? ref.path,
+        path: ref.path,
+        open: 0,
+        done: 0,
+        overdue: 0,
+        today: 0,
+        columns: [],
+        next: [],
+        diagnostics: -1,
+      });
+      continue;
+    }
+
+    const { board, diagnostics } = parseBoard(content, { filepath: ref.path });
+    const boardName = ref.name ?? board.name;
+    parsed.push(board);
+
+    const columns: SummaryColumn[] = [];
+    const openTasks: SummaryTask[] = [];
+    let open = 0;
+    let done = 0;
+    let overdue = 0;
+    let dueToday = 0;
+
+    for (const column of board.columns) {
+      const hidden = isHiddenColumn(config, column.name);
+      let columnOpen = 0;
+
+      for (const child of column.children) {
+        if (!isTask(child)) continue;
+        const task = child;
+
+        // Anything parked in Done/Archive counts as done wherever its checkbox
+        // sits — the column is the workflow truth, not the `- [x]` marker.
+        if (hidden || task.done) {
+          done++;
+          continue;
+        }
+
+        open++;
+        columnOpen++;
+
+        const date = effectiveDate(task);
+        const daysUntil = date ? daysBetween(today, date) : null;
+        if (daysUntil !== null && daysUntil < 0) overdue++;
+        if (daysUntil === 0) dueToday++;
+
+        openTasks.push({
+          title: task.displayTitle,
+          board: boardName,
+          column: column.name,
+          priority: task.priority,
+          due: task.due,
+          scheduled: task.scheduled,
+          assignee: task.assignee,
+          tags: task.tags,
+          daysUntil,
+        });
+      }
+
+      if (!hidden) columns.push({ name: column.name, open: columnOpen });
+    }
+
+    // Soonest first; undated tasks last; ties broken by priority then title so
+    // the order is stable between polls and the widget doesn't flicker.
+    openTasks.sort((a, b) => {
+      const ad = a.daysUntil ?? Number.POSITIVE_INFINITY;
+      const bd = b.daysUntil ?? Number.POSITIVE_INFINITY;
+      if (ad !== bd) return ad - bd;
+      const ap = PRIORITY_RANK[a.priority];
+      const bp = PRIORITY_RANK[b.priority];
+      if (ap !== bp) return ap - bp;
+      return a.title.localeCompare(b.title);
+    });
+
+    totals.open += open;
+    totals.done += done;
+    totals.overdue += overdue;
+    totals.today += dueToday;
+
+    boards.push({
+      name: boardName,
+      path: ref.path,
+      open,
+      done,
+      overdue,
+      today: dueToday,
+      columns,
+      next: openTasks.slice(0, nextCount),
+      diagnostics: diagnostics.length,
+    });
+  }
+
+  const planner: Record<PlannerSection, PlannerEntry[]> = {
+    overdue: [],
+    today: [],
+    tomorrow: [],
+  };
+  for (const item of buildPlannerItems(parsed)) {
+    planner[item.section].push({
+      title: item.task.displayTitle,
+      board: item.boardName,
+      column: item.columnName,
+      bucket: item.bucket,
+      priority: item.task.priority,
+      due: item.task.due,
+      scheduled: item.task.scheduled,
+      timeBlock: formatTimeBlock(item.task.timeBlock),
+      assignee: item.task.assignee,
+      done: item.task.done,
+      doneDate: item.task.doneDate,
+    });
+  }
+
+  return { generatedAt: new Date().toISOString(), totals, boards, planner };
+}
+
+export async function runSummary(argv: readonly string[]): Promise<number> {
+  let pretty = false;
+  let next: number | undefined;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === "--pretty") pretty = true;
+    else if (arg === "--next") next = Number(argv[++i]);
+    else if (arg.startsWith("--next=")) next = Number(arg.slice("--next=".length));
+    else {
+      console.error(`tuiboard summary: unknown argument "${arg}"`);
+      return 2;
+    }
+  }
+
+  if (next !== undefined && (!Number.isFinite(next) || next < 0)) {
+    console.error("tuiboard summary: --next needs a non-negative number");
+    return 2;
+  }
+
+  const summary = buildSummary({ next });
+  process.stdout.write(
+    (pretty ? JSON.stringify(summary, null, 2) : JSON.stringify(summary)) + "\n",
+  );
+  return 0;
+}

package/src/cli/task.ts

@@ -0,0 +1,235 @@
+/**
+ * Headless mutations on a board, for scripts and widgets.
+ *
+ *   tuiboard task done   --board <name> --column <col> --match <text>
+ *   tuiboard task undone --board <name> --column <col> --match <text>
+ *   tuiboard task add    --board <name> --column <col> --text <text>
+ *   tuiboard task defer --board <name> --column <col> --match <text> [--days N|--to DATE]
+ *   ... --dry-run     report what would change, write nothing
+ *
+ * Why match by text and not by index: a task's id is `${column}:${position}`,
+ * which is only valid inside one render pass. Anything outside the TUI — a
+ * widget polling every two minutes, a cron job — holds a stale snapshot, and
+ * acting on a stale index silently hits the wrong task. Matching on the
+ * rendered title instead makes a moved task a miss rather than a mistake.
+ *
+ * Concurrency is handled by writeBoardFile()'s mtime watermark: if the file
+ * changed since we read it, it throws ConflictError and we refuse the write.
+ */
+
+import { readFileSync } from "node:fs";
+
+import { loadConfig } from "~/config/loader";
+import { ConflictError, statMtime, writeBoardFile } from "~/io/writer";
+import { isTask, parseBoard } from "~/parser/markdown";
+import { serializeBoard } from "~/parser/serialize";
+import type { Board, Column, Task } from "~/types";
+
+interface Args {
+  board?: string;
+  column?: string;
+  match?: string;
+  text?: string;
+  days?: number;
+  to?: string;
+  dryRun: boolean;
+}
+
+function parse(argv: readonly string[]): Args {
+  const a: Args = { dryRun: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    const take = () => argv[++i];
+    if (arg === "--board") a.board = take();
+    else if (arg === "--column") a.column = take();
+    else if (arg === "--match") a.match = take();
+    else if (arg === "--text") a.text = take();
+    else if (arg === "--days") a.days = Number(take());
+    else if (arg === "--to") a.to = take();
+    else if (arg === "--dry-run") a.dryRun = true;
+    else if (arg.startsWith("--board=")) a.board = arg.slice(8);
+    else if (arg.startsWith("--column=")) a.column = arg.slice(9);
+    else if (arg.startsWith("--match=")) a.match = arg.slice(8);
+    else if (arg.startsWith("--text=")) a.text = arg.slice(7);
+    else if (arg.startsWith("--days=")) a.days = Number(arg.slice(7));
+    else if (arg.startsWith("--to=")) a.to = arg.slice(5);
+    else throw new Error(`unknown argument "${arg}"`);
+  }
+  return a;
+}
+
+function isoToday(): string {
+  const d = new Date();
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+function isoShift(days: number): string {
+  const d = new Date();
+  d.setDate(d.getDate() + days);
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+/** Resolve a board by configured name, then by path suffix. */
+function resolveBoard(needle: string) {
+  const cfg = loadConfig();
+  const lower = needle.toLowerCase();
+  const hit =
+    cfg.boards.find((b) => (b.name ?? "").toLowerCase() === lower) ??
+    cfg.boards.find((b) => b.path.toLowerCase().endsWith(lower));
+  if (!hit) {
+    const names = cfg.boards.map((b) => b.name ?? b.path).join(", ");
+    throw new Error(`board "${needle}" not found. Configured: ${names || "(none)"}`);
+  }
+  return hit;
+}
+
+function findColumn(board: Board, name: string): Column {
+  const lower = name.toLowerCase();
+  const col = board.columns.find((c) => c.name.toLowerCase() === lower);
+  if (!col) {
+    throw new Error(
+      `column "${name}" not found. Available: ${board.columns.map((c) => c.name).join(", ")}`,
+    );
+  }
+  return col;
+}
+
+/** Exactly one match or nothing: an ambiguous title must not be guessed at. */
+function findTask(col: Column, needle: string): Task {
+  const lower = needle.toLowerCase();
+  const tasks = col.children.filter(isTask);
+  let hits = tasks.filter((t) => t.displayTitle.toLowerCase() === lower);
+  if (hits.length === 0) {
+    hits = tasks.filter((t) => t.displayTitle.toLowerCase().includes(lower));
+  }
+  if (hits.length === 0) throw new Error(`no task in "${col.name}" matching "${needle}"`);
+  if (hits.length > 1) {
+    throw new Error(
+      `"${needle}" matches ${hits.length} tasks in "${col.name}"; be more specific`,
+    );
+  }
+  return hits[0]!;
+}
+
+export async function runTask(argv: readonly string[]): Promise<number> {
+  const sub = argv[0];
+  if (sub !== "done" && sub !== "undone" && sub !== "add" && sub !== "defer") {
+    console.error(
+      "usage: tuiboard task <done|undone|add|defer> --board <b> --column <c> [--match|--text] <s>",
+    );
+    return 2;
+  }
+
+  let a: Args;
+  try {
+    a = parse(argv.slice(1));
+  } catch (e) {
+    console.error(`tuiboard task: ${(e as Error).message}`);
+    return 2;
+  }
+
+  if (!a.board || !a.column) {
+    console.error("tuiboard task: --board and --column are required");
+    return 2;
+  }
+  if ((sub === "done" || sub === "undone" || sub === "defer") && !a.match) {
+    console.error(`tuiboard task ${sub}: --match is required`);
+    return 2;
+  }
+  if (sub === "defer" && a.days !== undefined && !Number.isFinite(a.days)) {
+    console.error("tuiboard task defer: --days must be a number");
+    return 2;
+  }
+  if (sub === "defer" && a.to !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(a.to)) {
+    console.error("tuiboard task defer: --to must be YYYY-MM-DD");
+    return 2;
+  }
+  if (sub === "add" && !a.text) {
+    console.error("tuiboard task add: --text is required");
+    return 2;
+  }
+
+  try {
+    const ref = resolveBoard(a.board);
+    const mtime = statMtime(ref.path);
+    const { board } = parseBoard(readFileSync(ref.path, "utf-8"), { filepath: ref.path });
+    const col = findColumn(board, a.column);
+
+    let summary: string;
+
+    if (sub === "done") {
+      const task = findTask(col, a.match!);
+      if (task.done) {
+        console.log(`already done: ${task.displayTitle}`);
+        return 0;
+      }
+      // Same semantics as the TUI's toggleDone: keep an existing completion
+      // date if one was already recorded, otherwise stamp today.
+      task.done = true;
+      task.dirty = true;
+      task.doneDate = task.doneDate ?? isoToday();
+      summary = `done: ${task.displayTitle}`;
+    } else if (sub === "undone") {
+      // The counterpart of `done`: ticking a task by mistake, or reopening one
+      // that turned out not to be finished, must not require the TUI.
+      // The completion date goes with it — a task that is open has not been
+      // completed on any date, and a stale ✅ would outlive the tick.
+      const task = findTask(col, a.match!);
+      if (!task.done) {
+        console.log(`already open: ${task.displayTitle}`);
+        return 0;
+      }
+      task.done = false;
+      task.doneDate = undefined;
+      task.dirty = true;
+      summary = `reopened: ${task.displayTitle}`;
+    } else if (sub === "defer") {
+      const task = findTask(col, a.match!);
+      const target = a.to ?? isoShift(a.days ?? 1);
+
+      // Move the field the planner actually reads. buildPlannerItems() buckets
+      // on `scheduled ?? due`, so shifting `due` on a task that also carries a
+      // `scheduled` date would write a change that never moves the row.
+      // A task with neither date gets a scheduled one, which is what puts it
+      // on the agenda in the first place.
+      if (task.scheduled !== undefined) task.scheduled = target;
+      else if (task.due !== undefined) task.due = target;
+      else task.scheduled = target;
+
+      task.dirty = true;
+      summary = `deferred to ${target}: ${task.displayTitle}`;
+    } else {
+      const task: Task = {
+        id: `${board.columns.indexOf(col)}:${col.children.filter(isTask).length}`,
+        done: false,
+        rawBody: a.text!,
+        rawLine: `- [ ] ${a.text!}`,
+        dirty: true,
+        displayTitle: a.text!,
+        tags: [],
+        wikilinks: [],
+        priority: "none",
+      };
+      col.children.push(task);
+      summary = `added to ${col.name}: ${a.text}`;
+    }
+
+    if (a.dryRun) {
+      console.log(`[dry-run] ${summary}`);
+      return 0;
+    }
+
+    writeBoardFile(ref.path, serializeBoard(board), { expectedMtimeMs: mtime });
+    console.log(summary);
+    return 0;
+  } catch (e) {
+    if (e instanceof ConflictError) {
+      console.error(`tuiboard task: the board changed on disk — refresh and retry.`);
+      return 3;
+    }
+    console.error(`tuiboard task: ${(e as Error).message}`);
+    return 1;
+  }
+}

package/src/config/loader.ts

@@ -43,6 +43,15 @@ export interface Config {
    * When unset, tuiboard falls back to opening a tab + `claude --resume <id>`.
    */
   resumeCommand?: string[];
+  /**
+   * Template for the shell command copied to the clipboard by `c` in the agents
+   * zone — one paste that `cd`s into the session's directory and resumes it.
+   * The tokens `{cwd}` and `{sessionId}` are substituted. Default:
+   *   cd "{cwd}" && claude --resume {sessionId}
+   * `&&` works in bash/zsh/pwsh/cmd; Nushell users may prefer
+   *   cd "{cwd}"; claude --resume {sessionId}
+   */
+  copyResumeCommand: string;
   /**
    * Optional read-only calendar feeds merged into the Agenda (timeline) zone.
    * Paths support `~` and are resolved against the config dir if relative.
@@ -102,10 +111,18 @@ export interface CalendarsConfig {
   microsoft?: MicrosoftCalendarConfig;
 }
 
+/**
+ * Default clipboard template for `c` in the agents zone: `cd` + resume in one
+ * paste. `&&` chains in bash/zsh/pwsh/cmd (Nushell users override with `;`).
+ */
+export const DEFAULT_COPY_RESUME_COMMAND =
+  'cd "{cwd}" && claude --resume {sessionId}';
+
 export const DEFAULT_CONFIG: Omit<Config, "root" | "loaded" | "boards"> = {
   assignees: [],
   doneColumn: "Done",
   archiveColumn: "Archive",
+  copyResumeCommand: DEFAULT_COPY_RESUME_COMMAND,
   zones: { planner: "on", agenda: "on", agents: "on" },
 };
 
@@ -149,6 +166,7 @@ interface RawConfig {
   done_column: string;
   archive_column: string;
   resume_command: string[];
+  copy_resume_command: string;
   calendars: {
     google?: {
       enabled?: boolean;
@@ -293,6 +311,11 @@ 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,
+    copyResumeCommand:
+      typeof raw.copy_resume_command === "string" &&
+      raw.copy_resume_command.trim().length > 0
+        ? raw.copy_resume_command
+        : DEFAULT_COPY_RESUME_COMMAND,
     calendars: normalizeCalendars(raw.calendars, root),
     zones: normalizeZones(raw.zones),
   };

package/src/input/handleKey.ts

@@ -432,6 +432,20 @@ function handleAgentsZone(store: TuiStore, key: KeyEvent): void {
     // Open (resume) the selected session in a new WezTerm tab.
     const target = sessions[ui.row];
     if (target) void openSessionInWezterm(store, target.cwd, target.sessionId);
+  } else if (key.name === "c") {
+    // Copy a one-paste "cd + resume" command for the selected session, so you
+    // can drop it into any tab/pane anywhere and land in the right directory
+    // resuming the right session (no WezTerm dependency, unlike Enter).
+    const target = sessions[ui.row];
+    if (target) {
+      const cmd = store.config.copyResumeCommand
+        .replaceAll("{cwd}", target.cwd)
+        .replaceAll("{sessionId}", target.sessionId);
+      copyToClipboard(cmd).then(
+        () => store.flashBanner("info", `📋 Copied resume command (${target.sessionId.slice(0, 8)})`),
+        (err) => store.flashBanner("error", `Copy failed: ${err}`),
+      );
+    }
   } else if (key.name === "o") {
     // Inspect the session in the detail modal.
     const target = sessions[ui.row];

package/src/store/index.test.ts

@@ -18,6 +18,7 @@ function emptyConfig(overrides: Partial<Config> = {}): Config {
     assignees: [],
     doneColumn: "Done",
     archiveColumn: "Archive",
+    copyResumeCommand: 'cd "{cwd}" && claude --resume {sessionId}',
     zones: { planner: "on", agenda: "on", agents: "on" },
     ...overrides,
   };

package/src/ui/Modal.tsx

@@ -772,12 +772,14 @@ function AgentDetailModal(props: { store: TuiStore; modal: Extract<NonNullable<T
             <box style={{ height: 1 }} />
             <text>
               <span style={{ fg: T.textDim }}>
-                resume — press Enter in the agents list to open this in WezTerm:
+                resume — Enter opens this in WezTerm; c copies this command to paste anywhere:
               </span>
             </text>
             <text wrapMode="word">
               <span style={{ fg: T.scheduled }}>
-                claude --resume {s().sessionId}
+                {props.store.config.copyResumeCommand
+                  .replaceAll("{cwd}", s().cwd)
+                  .replaceAll("{sessionId}", s().sessionId)}
               </span>
             </text>
           </box>
@@ -845,6 +847,7 @@ function HelpModal(props: { store: TuiStore }) {
         <span style={{ fg: T.text }}>{"  /                 Search task titles — jumps cursor to first match\n"}</span>
         <span style={{ fg: T.textDim }}>{"\nAgents zone\n"}</span>
         <span style={{ fg: T.text }}>{"  Enter             Open (resume) the selected session in a new WezTerm tab\n"}</span>
+        <span style={{ fg: T.text }}>{"  c                 Copy a 'cd + claude --resume' command for the session\n"}</span>
         <span style={{ fg: T.text }}>{"  o                 Session detail (cwd, branch, last prompts, resume cmd)\n"}</span>
         <span style={{ fg: T.textDim }}>{"\nMulti-select\n"}</span>
         <span style={{ fg: T.text }}>{"  Space             Mark / unmark task (cursor stays — mark in any order)\n"}</span>

package/src/ui/splash-boot.ts

@@ -0,0 +1,21 @@
+/**
+ * Side-effect module: paints the boot splash the moment it's imported.
+ *
+ * app.tsx imports this FIRST so the splash prints before `@opentui/solid`
+ * (and the ~600ms store build) load — ES modules run imported modules in
+ * source order, so a first-position side-effect import is the only way to
+ * paint before the heavy imports execute.
+ *
+ * When launched via the `tuiboard` bin, the launcher already printed the splash
+ * (and sets TUIBOARD_SPLASH_DONE), so this no-ops to avoid a double paint.
+ */
+
+import pkg from "../../package.json";
+import { printSplash, showCursor } from "./splash";
+
+if (!process.env.TUIBOARD_SPLASH_DONE) printSplash(pkg.version);
+
+// The splash hides the cursor; guarantee it's restored on every exit path of
+// this process, so quitting never leaves the shell without a cursor. (OpenTUI
+// also restores on clean exit; this is the belt-and-suspenders backstop.)
+process.on("exit", showCursor);