tuiboard 0.13.1 → 0.13.3

package/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.3] - 2026-09-19
+
+### Fixed
+- **`tuiboard task --board` refuses ambiguous boards** (#63) instead of taking
+  the first configured board whose path ends with the argument. Two boards can
+  easily end the same way (`Work/Personal.md`, `Home/Personal.md`), and this is
+  the headless path used by cron jobs and the bar widget, so the wrong board
+  could be mutated silently. It now lists the candidates and writes nothing,
+  the way an ambiguous `--match` already did. Thanks to the commenter on
+  Reddit who spotted it.
+
+## [0.13.2] - 2026-09-17
+
+### Fixed
+- **A calmer Agents list while agents work** (#58).
+  - A failed herdr poll no longer drops every link at once (states briefly
+    reverting, rows jumping); herdr only counts as gone after a few misses.
+  - A Claude Code PID file read mid-write reuses its last good read instead of
+    making the session's state flicker.
+  - Live sessions are ordered by their activity at their last state change,
+    so a working agent moves once when it starts or finishes, not on every
+    write; closed sessions still sort by last activity.
+  - Ages tick on one shared clock and read `now` under a minute instead of
+    jumping through seconds.
+
 ## [0.13.1] - 2026-09-17
 
 ### Fixed
@@ -487,6 +512,8 @@ First public release on npm. This entry captures the full feature set at launch.
 
 Built with [OpenTUI](https://opentui.com) + SolidJS on Bun.
 
+[0.13.3]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.13.3
+[0.13.2]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.13.2
 [0.13.1]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.13.1
 [0.13.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.13.0
 [0.12.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuiboard",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "Terminal kanban for markdown task boards, with optional Today/Tomorrow planner, 24h agenda + calendar overlay, and a live view of your coding-agent sessions (Claude Code, Codex, OpenCode, Pi). Use only the panels you want.",
   "type": "module",
   "license": "MIT",

package/src/cli/task.ts

@@ -71,18 +71,31 @@ function isoShift(days: number): string {
   return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
 }
 
-/** Resolve a board by configured name, then by path suffix. */
+/**
+ * Resolve a board by configured name, then by path suffix — and refuse to
+ * guess when more than one matches, the way findTask does for task titles.
+ * Two boards can easily end the same way (`Work/Personal.md`,
+ * `Home/Personal.md`), and this is the headless path: a cron job or the bar
+ * widget mutating the wrong board would go unnoticed.
+ */
 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 byName = cfg.boards.filter((b) => (b.name ?? "").toLowerCase() === lower);
+  const hits = byName.length > 0
+    ? byName
+    : cfg.boards.filter((b) => b.path.toLowerCase().endsWith(lower));
+  if (hits.length === 0) {
     const names = cfg.boards.map((b) => b.name ?? b.path).join(", ");
     throw new Error(`board "${needle}" not found. Configured: ${names || "(none)"}`);
   }
-  return hit;
+  if (hits.length > 1) {
+    const candidates = hits.map((b) => (b.name ? `${b.name} (${b.path})` : b.path)).join(", ");
+    throw new Error(
+      `board "${needle}" matches ${hits.length} boards: ${candidates}; be more specific`,
+    );
+  }
+  return hits[0]!;
 }
 
 function findColumn(board: Board, name: string): Column {

package/src/store/agent-adapters/claude-code.ts

@@ -207,6 +207,13 @@ export function parseTranscript(content: string): TranscriptParseResult {
 
 // ─── Discovery ──────────────────────────────────────────────────────────────
 
+/**
+ * Last successfully parsed record per PID file. Claude Code rewrites these
+ * files in place, so a read can land mid-write; reusing the previous record
+ * keeps the session's live state from flickering for one scan.
+ */
+const lastGoodPid = new Map<string, { sessionId: string; record: LivePidRecord }>();
+
 function discoverLivePids(): Map<string, LivePidRecord> {
   const out = new Map<string, LivePidRecord>();
   if (!existsSync(SESSIONS_DIR)) return out;
@@ -216,25 +223,32 @@ function discoverLivePids(): Map<string, LivePidRecord> {
   } catch {
     return out;
   }
+  const seen = new Set<string>();
   for (const f of entries) {
     if (!f.endsWith(".json")) continue;
     const path = join(SESSIONS_DIR, f);
+    seen.add(path);
     try {
       const raw = JSON.parse(readFileSync(path, "utf-8"));
       const sid = raw.sessionId;
       if (!sid) continue;
       const stat = statSync(path);
-      out.set(sid, {
+      const record: LivePidRecord = {
         mtimeMs: stat.mtimeMs,
         status: raw.status?.toLowerCase(),
         pid: raw.pid,
         version: raw.version,
         cwd: raw.cwd,
-      });
+      };
+      lastGoodPid.set(path, { sessionId: sid, record });
+      out.set(sid, record);
     } catch {
-      // ignore — malformed PID files happen during writes
+      // Mid-write (or vanished): fall back to the last good read of this file.
+      const prev = lastGoodPid.get(path);
+      if (prev) out.set(prev.sessionId, prev.record);
     }
   }
+  for (const path of lastGoodPid.keys()) if (!seen.has(path)) lastGoodPid.delete(path);
   return out;
 }
 

package/src/store/agents.ts

@@ -73,6 +73,11 @@ export interface AgentSession {
   resumeArgv: string[];
   /** Set when the session is open in a herdr pane. */
   herdr?: HerdrLink;
+  /**
+   * Position in the list (newest first). Set by the store: last activity for
+   * closed sessions, last state change for live ones — see withSortKeys.
+   */
+  sortKeyMs?: number;
 }
 
 /** One agent CLI's session source. */
@@ -113,11 +118,11 @@ export function filterSessions(arr: AgentSession[], filter: AgentsFilter): Agent
   return filter === "all" ? arr : arr.filter((s) => s.provider === filter);
 }
 
-/** Compact human-readable age. Mirrors av.py `_fmt_age`. */
+/** Compact human-readable age; under a minute reads `now` (no ticking seconds). */
 export function formatAge(ts: number, now: number): string {
   if (!ts) return "—";
   const delta = (now - ts) / 1000;
-  if (delta < 60) return `${Math.floor(delta)}s`;
+  if (delta < 60) return "now";
   if (delta < 3600) return `${Math.floor(delta / 60)}m`;
   if (delta < 86_400) return `${Math.floor(delta / 3600)}h`;
   return `${Math.floor(delta / 86_400)}d`;
@@ -144,15 +149,48 @@ export function isLive(status: AgentStatus): boolean {
  * cursor indices aligned with the full list.
  */
 export function sortSessions(arr: AgentSession[]): AgentSession[] {
+  const key = (s: AgentSession) => s.sortKeyMs ?? s.lastActivityMs;
   return arr.slice().sort((a, b) => {
     const archived = Number(a.status === "archived") - Number(b.status === "archived");
     if (archived !== 0) return archived;
-    const recency = b.lastActivityMs - a.lastActivityMs;
+    const recency = key(b) - key(a);
     if (recency !== 0) return recency;
     return STATUS_RANK[a.status] - STATUS_RANK[b.status];
   });
 }
 
+export interface StateMemory {
+  status: AgentStatus;
+  since: number;
+}
+
+/**
+ * Sort keys that don't churn. A working agent writes its session file all
+ * the time; sorting by that made rows swap on every write. Live sessions are
+ * keyed by their last activity *as of their last state change* — they move
+ * once when they start or finish (both write), not on every write — and
+ * closed ones by their last activity. Using activity rather than the wall
+ * clock means a "change" that is only new information (herdr answering after
+ * the first scan) doesn't reshuffle the list.
+ * `memory` carries state across refreshes (keyed by provider + session id).
+ */
+export function withSortKeys(
+  sessions: AgentSession[],
+  memory: Map<string, StateMemory>,
+): AgentSession[] {
+  const seen = new Set<string>();
+  const out = sessions.map((s) => {
+    const id = `${s.provider}:${s.sessionId}`;
+    seen.add(id);
+    const prev = memory.get(id);
+    const since = prev && prev.status === s.status ? prev.since : s.lastActivityMs;
+    memory.set(id, { status: s.status, since });
+    return { ...s, sortKeyMs: isLive(s.status) ? since : s.lastActivityMs };
+  });
+  for (const id of memory.keys()) if (!seen.has(id)) memory.delete(id);
+  return out;
+}
+
 // ─── Reactive store ─────────────────────────────────────────────────────────
 
 export interface AgentsStore {
@@ -195,9 +233,11 @@ export function createAgentsStore(
     }
   }
 
+  const stateMemory = new Map<string, StateMemory>();
   function publish(): void {
     const all = [...byAdapter.values()].flat();
-    setSessions(sortSessions(linkHerdrSessions(all, herdr?.snapshot())));
+    const linked = linkHerdrSessions(all, herdr?.snapshot());
+    setSessions(sortSessions(withSortKeys(linked, stateMemory)));
   }
   herdr?.onChange(publish);
 

package/src/store/herdr.ts

@@ -213,6 +213,11 @@ export interface HerdrSource {
 }
 
 export const HERDR_POLL_MS = 2000;
+/**
+ * Consecutive failed polls before herdr counts as gone. A single slow or
+ * failed call used to drop every link at once, making states flicker.
+ */
+export const HERDR_MISSES_BEFORE_CLEAR = 3;
 
 /**
  * Poll `herdr api snapshot` in the background. Inert when herdr isn't on
@@ -220,7 +225,11 @@ export const HERDR_POLL_MS = 2000;
  * without noise.
  */
 export function createHerdrSource(
-  { pollMs = HERDR_POLL_MS, bin = Bun.which("herdr") }: { pollMs?: number; bin?: string | null } = {},
+  {
+    pollMs = HERDR_POLL_MS,
+    bin = Bun.which("herdr"),
+    missesBeforeClear = HERDR_MISSES_BEFORE_CLEAR,
+  }: { pollMs?: number; bin?: string | null; missesBeforeClear?: number } = {},
 ): HerdrSource {
   let current: HerdrSnapshot | undefined;
   let lastRaw = "";
@@ -229,6 +238,7 @@ export function createHerdrSource(
 
   let inFlight = false;
   let disposed = false;
+  let misses = 0;
   const poll = async () => {
     if (inFlight || disposed) return;
     inFlight = true;
@@ -242,7 +252,9 @@ export function createHerdrSource(
       const out = await new Response(proc.stdout).text();
       clearTimeout(timer);
       const code = await proc.exited;
-      const snap = code === 0 ? parseHerdrSnapshot(out) : undefined;
+      let snap = code === 0 ? parseHerdrSnapshot(out) : undefined;
+      if (snap) misses = 0;
+      else if (++misses < missesBeforeClear) snap = current; // ride out a blip
       // Only the parts we use decide whether anything changed.
       const key = snap
         ? JSON.stringify([snap.panes, [...snap.tabs], [...snap.workspaces]])
@@ -253,7 +265,8 @@ export function createHerdrSource(
         for (const cb of listeners) cb();
       }
     } catch {
-      // herdr vanished mid-call — try again next tick
+      // herdr vanished mid-call — counts as a miss, try again next tick
+      misses++;
     } finally {
       inFlight = false;
     }

package/src/ui/AgentRow.tsx

@@ -15,6 +15,7 @@ import { Show, createMemo, createSignal, onMount } from "solid-js";
 import { homedir } from "node:os";
 
 import { layoutCardDetails, layoutCardName, layoutLine } from "~/ui/agent-line";
+import { clockNow } from "~/ui/clock";
 import { T } from "~/ui/glyphs";
 import { herdrPlace, type IndicatorStyle } from "~/store/herdr";
 import {
@@ -95,7 +96,7 @@ interface AgentRowProps {
 
 export function AgentRow(props: AgentRowProps) {
   const ageStr = createMemo(() =>
-    formatAge(props.session.lastActivityMs, Date.now()),
+    formatAge(props.session.lastActivityMs, clockNow()),
   );
   const nameMax = () => props.nameMaxChars ?? 40;
   const displayName = createMemo(() => {

package/src/ui/clock.ts

@@ -0,0 +1,21 @@
+/**
+ * A shared, coarse clock for relative times ("5m", "3h"). Rows used to compute
+ * their age only when their data changed, so ages jumped irregularly while
+ * agents worked; one timer for the whole UI keeps them ticking evenly.
+ */
+
+import { createSignal } from "solid-js";
+
+export const CLOCK_TICK_MS = 30_000;
+
+const [now, setNow] = createSignal(Date.now());
+let timer: ReturnType<typeof setInterval> | undefined;
+
+/** Current time, updated every CLOCK_TICK_MS. Starts on first use. */
+export function clockNow(): number {
+  if (!timer) {
+    timer = setInterval(() => setNow(Date.now()), CLOCK_TICK_MS);
+    timer.unref?.();
+  }
+  return now();
+}