@taskmark/ui 0.2.6 → 0.3.1

package/lib/taskmark/parse-items.ts

@@ -15,8 +15,9 @@ import {
   extractFrontmatter,
 } from "@/lib/taskmark/frontmatter"
 import { asContributorList } from "@/lib/taskmark/identity"
+import type { BoardIndex, IndexedLeaf } from "@/lib/taskmark/board-index"
 import { findEpicFolder } from "@/lib/taskmark/parse-stories"
-import { readTimingFields } from "@/lib/taskmark/timing"
+import { readActualTimingFromWorkLog } from "@/lib/taskmark/timing"
 
 type StoryFolder = {
   dirName: string
@@ -118,11 +119,12 @@ function parseItemFile(
   filePath: string,
   project: DiscoveredProject,
   parentId: string,
-  epicId: string
+  epicId: string,
+  indexed?: IndexedLeaf
 ): { item?: ItemSummary; error?: ItemParseError } {
   let raw: string
   try {
-    raw = fs.readFileSync(filePath, "utf8")
+    raw = indexed?.raw ?? fs.readFileSync(filePath, "utf8")
   } catch (err) {
     return {
       error: {
@@ -137,7 +139,7 @@ function parseItemFile(
 
   let frontmatter: Record<string, unknown> | null
   try {
-    frontmatter = extractFrontmatter(raw)
+    frontmatter = indexed?.frontmatter ?? extractFrontmatter(raw)
   } catch (err) {
     return {
       error: {
@@ -186,11 +188,17 @@ function parseItemFile(
       priority: asString(frontmatter.priority, "medium"),
       size: asString(frontmatter.size, "—"),
       points: asNumberOrNull(frontmatter.points),
-      ...readTimingFields(frontmatter),
+      ...(indexed
+        ? {
+            actualMinutes: indexed.actualMinutes,
+            actualMs: indexed.actualMs,
+          }
+        : readActualTimingFromWorkLog(raw)),
       tags: asStringArray(frontmatter.tags),
       reporters: asContributorList(frontmatter.reporters),
       resolvers: asContributorList(frontmatter.resolvers),
       created: asString(frontmatter.created),
+      updated: asString(frontmatter.updated),
       completedAt: asString(frontmatter.completed_at),
       parent: asString(frontmatter.parent, parentId),
       epic: asString(frontmatter.epic, epicId),
@@ -211,7 +219,8 @@ function parseItemFile(
 export function parseItemsForStory(
   project: DiscoveredProject,
   epicId: string,
-  storyId: string
+  storyId: string,
+  index?: BoardIndex
 ): StoryItemList {
   const folder = findStoryFolder(project.boardPath, epicId, storyId)
   if (!folder) {
@@ -246,11 +255,25 @@ export function parseItemsForStory(
     folder.dirName
   )
   const files = listItemMarkdownFiles(storyDir)
+  const indexedByPath = index
+    ? new Map(
+        (index.leavesByParent.get(storyId) ?? []).map((leaf) => [
+          leaf.filePath,
+          leaf,
+        ])
+      )
+    : null
   const items: ItemSummary[] = []
   const errors: ItemParseError[] = []
 
   for (const filePath of files) {
-    const result = parseItemFile(filePath, project, storyId, epicId)
+    const result = parseItemFile(
+      filePath,
+      project,
+      storyId,
+      epicId,
+      indexedByPath?.get(filePath)
+    )
     if (result.item) items.push(result.item)
     if (result.error) errors.push(result.error)
   }
@@ -272,7 +295,8 @@ export function parseItemsForStory(
  */
 export function parseItemsForEpic(
   project: DiscoveredProject,
-  epicId: string
+  epicId: string,
+  index?: BoardIndex
 ): StoryItemList {
   const epic = findEpicFolder(project.boardPath, epicId)
   if (!epic) {
@@ -296,11 +320,25 @@ export function parseItemsForEpic(
 
   const epicDir = path.join(project.boardPath, "epics", epic.dirName)
   const files = listItemMarkdownFiles(epicDir)
+  const indexedByPath = index
+    ? new Map(
+        (index.leavesByParent.get(epicId) ?? []).map((leaf) => [
+          leaf.filePath,
+          leaf,
+        ])
+      )
+    : null
   const items: ItemSummary[] = []
   const errors: ItemParseError[] = []
 
   for (const filePath of files) {
-    const result = parseItemFile(filePath, project, epicId, epicId)
+    const result = parseItemFile(
+      filePath,
+      project,
+      epicId,
+      epicId,
+      indexedByPath?.get(filePath)
+    )
     if (result.item) items.push(result.item)
     if (result.error) errors.push(result.error)
   }

package/lib/taskmark/parse-stories.ts

@@ -8,14 +8,13 @@ import type {
   StorySummary,
 } from "@/lib/taskmark/story-types"
 import {
-  asNumberOrNull,
   asString,
   asStringArray,
   extractFrontmatter,
 } from "@/lib/taskmark/frontmatter"
 import { asContributorList } from "@/lib/taskmark/identity"
-import { readTimingFields } from "@/lib/taskmark/timing"
-import { progressUnderStory } from "@/lib/taskmark/count-leaves"
+import { deriveParentRollup } from "@/lib/taskmark/derive-parents"
+import type { BoardIndex } from "@/lib/taskmark/board-index"
 
 type EpicFolder = {
   dirName: string
@@ -97,7 +96,8 @@ function listStoryMarkdownFiles(epicDir: string): string[] {
 function parseStoryFile(
   filePath: string,
   project: DiscoveredProject,
-  epicId: string
+  epicId: string,
+  index?: BoardIndex
 ): { story?: StorySummary; error?: StoryParseError } {
   let raw: string
   try {
@@ -156,26 +156,28 @@ function parseStoryFile(
     }
   }
 
-  const progress = progressUnderStory(project.boardPath, epicId, id)
+  const derived = deriveParentRollup(project.boardPath, id, "story", index)
 
   return {
     story: {
       id,
       title,
-      status: asString(frontmatter.status, "unknown"),
+      status: derived.status,
       priority: asString(frontmatter.priority, "medium"),
-      size: asString(frontmatter.size, "—"),
-      points: asNumberOrNull(frontmatter.points),
-      ...readTimingFields(frontmatter),
+      size: derived.size,
+      points: derived.points,
+      actualMinutes: derived.actualMinutes,
+      actualMs: derived.actualMs,
       tags: asStringArray(frontmatter.tags),
       reporters: asContributorList(frontmatter.reporters),
-      resolvers: asContributorList(frontmatter.resolvers),
+      resolvers: derived.resolvers,
       created: asString(frontmatter.created),
-      completedAt: asString(frontmatter.completed_at),
+      updated: asString(frontmatter.updated),
+      completedAt: derived.completedAt,
       parent: asString(frontmatter.parent),
       epic: asString(frontmatter.epic, epicId),
-      workItemCount: progress.total,
-      doneWorkItemCount: progress.done,
+      workItemCount: derived.leafCount,
+      doneWorkItemCount: derived.doneLeafCount,
       filePath,
       project: {
         id: project.id,
@@ -193,7 +195,8 @@ function parseStoryFile(
  */
 export function parseStoriesForEpic(
   project: DiscoveredProject,
-  epicId: string
+  epicId: string,
+  index?: BoardIndex
 ): EpicStoryList {
   const folder = findEpicFolder(project.boardPath, epicId)
   if (!folder) {
@@ -220,7 +223,7 @@ export function parseStoriesForEpic(
   const errors: StoryParseError[] = []
 
   for (const filePath of files) {
-    const result = parseStoryFile(filePath, project, epicId)
+    const result = parseStoryFile(filePath, project, epicId, index)
     if (result.story) stories.push(result.story)
     if (result.error) errors.push(result.error)
   }

package/lib/taskmark/points-calendar.test.ts

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import {
+  POINTS_CALENDAR_WEEKS,
+  buildPointsCalendar,
+  pointsHeatLevel,
+} from "./points-calendar"
+
+const NOW = new Date(2026, 7, 29)
+
+test("empty boards fill a year of weeks with zero days", () => {
+  const calendar = buildPointsCalendar([], NOW)
+  assert.equal(calendar.weeks.length, POINTS_CALENDAR_WEEKS)
+  assert.ok(calendar.weeks.every((week) => week.days.length === 7))
+  assert.equal(calendar.maxPoints, 0)
+  assert.equal(calendar.totalPoints, 0)
+})
+
+test("a single done leaf lands on its own day", () => {
+  const calendar = buildPointsCalendar(
+    [{ completedAt: "2026-08-26T12:00:00Z", points: 5 }],
+    NOW
+  )
+  const days = calendar.weeks.flatMap((week) => week.days)
+  const filled = days.filter((day) => day.points > 0)
+  assert.equal(filled.length, 1)
+  assert.equal(filled[0]?.key, "2026-08-26")
+  assert.equal(calendar.maxPoints, 5)
+})
+
+test("two leaves on the same day sum points", () => {
+  const calendar = buildPointsCalendar(
+    [
+      { completedAt: "2026-08-26", points: 3 },
+      { completedAt: "2026-08-26T18:00:00Z", points: 5 },
+    ],
+    NOW
+  )
+  const day = calendar.weeks
+    .flatMap((week) => week.days)
+    .find((candidate) => candidate.key === "2026-08-26")
+  assert.equal(day?.points, 8)
+  assert.equal(calendar.totalPoints, 8)
+})
+
+test("skips unparseable dates and non-positive points", () => {
+  const calendar = buildPointsCalendar(
+    [
+      { completedAt: "not-a-date", points: 8 },
+      { completedAt: "2026-08-26", points: 0 },
+      { completedAt: "2026-08-26", points: -2 },
+    ],
+    NOW
+  )
+  assert.equal(calendar.totalPoints, 0)
+})
+
+test("marks days after today as future", () => {
+  const calendar = buildPointsCalendar([], NOW)
+  const days = calendar.weeks.flatMap((week) => week.days)
+  const today = days.find((day) => day.key === "2026-08-29")
+  const tomorrow = days.find((day) => day.key === "2026-08-30")
+  assert.equal(today?.isFuture, false)
+  assert.equal(tomorrow?.isFuture, true)
+})
+
+test("scales intensity from empty to the calendar maximum", () => {
+  assert.equal(pointsHeatLevel(0, 8), 0)
+  assert.equal(pointsHeatLevel(2, 8), 1)
+  assert.equal(pointsHeatLevel(8, 8), 4)
+})

package/lib/taskmark/points-calendar.ts

@@ -0,0 +1,86 @@
+import { addDays, endOfISOWeek, startOfDay, startOfISOWeek, subWeeks } from "date-fns"
+
+import {
+  sumPointsByDate,
+  toDateOnlyString,
+  type SolvedCompletionSample,
+} from "@/lib/taskmark/timeframe-filters"
+
+/** Columns in the calendar: one year of ISO weeks ending at the current week. */
+export const POINTS_CALENDAR_WEEKS = 53
+
+export type PointsCalendarDay = {
+  date: Date
+  /** YYYY-MM-DD */
+  key: string
+  points: number
+  /** Days after today: rendered as blanks so the grid stays honest. */
+  isFuture: boolean
+}
+
+export type PointsCalendarWeek = {
+  key: string
+  days: PointsCalendarDay[]
+}
+
+export type PointsCalendar = {
+  weeks: PointsCalendarWeek[]
+  maxPoints: number
+  totalPoints: number
+  start: Date
+  end: Date
+}
+
+/**
+ * Daily story points completed on done task/bug leaves, laid out as a
+ * contribution calendar: every column is an ISO week, every cell one day.
+ * Days without completions are zeros, never missing cells.
+ */
+export function buildPointsCalendar(
+  samples: readonly SolvedCompletionSample[],
+  now: Date = new Date()
+): PointsCalendar {
+  const totals = sumPointsByDate(samples)
+  const start = startOfISOWeek(subWeeks(now, POINTS_CALENDAR_WEEKS - 1))
+  const end = endOfISOWeek(now)
+  const today = startOfDay(now)
+
+  const weeks: PointsCalendarWeek[] = []
+  let maxPoints = 0
+  let totalPoints = 0
+  let cursor = start
+
+  while (cursor.getTime() <= end.getTime()) {
+    const days: PointsCalendarDay[] = []
+    for (let offset = 0; offset < 7; offset++) {
+      const date = addDays(cursor, offset)
+      const key = toDateOnlyString(date)
+      const points = totals.get(key) ?? 0
+      maxPoints = Math.max(maxPoints, points)
+      totalPoints += points
+      days.push({
+        date,
+        key,
+        points,
+        isFuture: startOfDay(date).getTime() > today.getTime(),
+      })
+    }
+    weeks.push({ key: toDateOnlyString(cursor), days })
+    cursor = addDays(cursor, 7)
+  }
+
+  return { weeks, maxPoints, totalPoints, start, end }
+}
+
+/** Discrete 0–4 intensity from empty through the calendar maximum. */
+export function pointsHeatLevel(
+  points: number,
+  maxPoints: number
+): 0 | 1 | 2 | 3 | 4 {
+  if (points <= 0 || maxPoints <= 0) return 0
+  const ratio = points / maxPoints
+  if (ratio <= 0.25) return 1
+  if (ratio <= 0.5) return 2
+  if (ratio <= 0.75) return 3
+  return 4
+}

package/lib/taskmark/project-metrics.ts

@@ -6,6 +6,7 @@
 import { addDays } from "date-fns"
 
 import type { ContributorIdentity } from "@/lib/taskmark/identity"
+import type { BoardIndex } from "@/lib/taskmark/board-index"
 import { parseEpicsForProject } from "@/lib/taskmark/parse-epics"
 import { parseItemsForEpic, parseItemsForStory } from "@/lib/taskmark/parse-items"
 import { parseStoriesForEpic } from "@/lib/taskmark/parse-stories"
@@ -206,9 +207,10 @@ export function computeCurrentWeekPointsDone(
 
 /** Walk the board and collect metric leaves (stories, tasks, bugs + epic identities for contributors). */
 export function collectMetricLeaves(
-  project: DiscoveredProject
+  project: DiscoveredProject,
+  index?: BoardIndex
 ): MetricLeaf[] {
-  const epicList = parseEpicsForProject(project)
+  const epicList = parseEpicsForProject(project, index)
   const leaves: MetricLeaf[] = []
 
   for (const epic of epicList.epics) {
@@ -222,7 +224,7 @@ export function collectMetricLeaves(
       resolvers: epic.resolvers,
     })
 
-    const storyList = parseStoriesForEpic(project, epic.id)
+    const storyList = parseStoriesForEpic(project, epic.id, index)
     for (const story of storyList.stories) {
       leaves.push({
         kind: "story",
@@ -234,7 +236,7 @@ export function collectMetricLeaves(
         resolvers: story.resolvers,
       })
 
-      const items = parseItemsForStory(project, epic.id, story.id)
+      const items = parseItemsForStory(project, epic.id, story.id, index)
       for (const item of items.items) {
         leaves.push({
           kind: item.type,
@@ -248,7 +250,7 @@ export function collectMetricLeaves(
       }
     }
 
-    const epicItems = parseItemsForEpic(project, epic.id)
+    const epicItems = parseItemsForEpic(project, epic.id, index)
     for (const item of epicItems.items) {
       leaves.push({
         kind: item.type,
@@ -266,9 +268,11 @@ export function collectMetricLeaves(
 }
 
 export function computeProjectStatusMetrics(
-  project: DiscoveredProject
+  project: DiscoveredProject,
+  index?: BoardIndex,
+  collectedLeaves?: readonly MetricLeaf[]
 ): ProjectStatusMetrics {
-  const leaves = collectMetricLeaves(project)
+  const leaves = collectedLeaves ?? collectMetricLeaves(project, index)
   const { total, complete } = aggregateWorkItemCounts(leaves)
   const currentWeekPointsDone = computeCurrentWeekPointsDone(leaves)
   const speed = computeCurrentSpeedPtsPerWeek(leaves)

package/lib/taskmark/snapshot-types.ts

@@ -25,6 +25,8 @@ export type BoardSnapshot = {
   itemsByStory: Record<string, StoryItemList>
   statusMetrics: ProjectStatusMetrics
   countableCompletions: SolvedCompletionSample[]
+  /** Board-root CHANGELOG.md; null when missing or whitespace-only. */
+  changelogMarkdown: string | null
   hideCompletedDefaults: Record<HideCompletedCookieKey, boolean>
   /** Absolute file path → detail (children attached) */
   detailsByPath: Record<string, WorkItemDetail>

package/lib/taskmark/story-types.ts

@@ -8,7 +8,6 @@ export type StorySummary = {
   priority: string
   size: string
   points: number | null
-  estimateMinutes: number | null
   actualMinutes: number | null
   actualMs: number | null
   tags: string[]
@@ -16,6 +15,8 @@ export type StorySummary = {
   resolvers: ContributorIdentity[]
   /** Frontmatter created date (YYYY-MM-DD or ISO). */
   created: string
+  /** Frontmatter updated date (YYYY-MM-DD or ISO). */
+  updated: string
   /** Frontmatter completed_at (ISO) when solved; empty if open. */
   completedAt: string
   parent: string

package/lib/taskmark/table-sort.ts

@@ -27,13 +27,14 @@ export type TableSortState = {
   direction: TableSortDirection
 }
 
-/** T-shirt rank: XS < S < M < L < XL. Unknown / empty sorts last. */
+/** Static t-shirt rank: XS < S < M < L < XL < XXL. */
 const SIZE_RANK: Record<string, number> = {
   XS: 1,
   S: 2,
   M: 3,
   L: 4,
   XL: 5,
+  XXL: 6,
 }
 
 const ID_PREFIX_RANK: Record<string, number> = {
@@ -54,8 +55,8 @@ export function sizeSortRank(size: string | null | undefined): number | null {
 }
 
 /**
- * Natural Taskmark id compare: prefix (E/S/T/B) then numeric suffix.
- * Falls back to case-insensitive string compare.
+ * Natural Taskmark id compare for legacy numeric IDs. Collision-resistant IDs
+ * use the general natural fallback and are never constrained to an NNN shape.
  */
 export function compareTaskmarkIds(a: string, b: string): number {
   const pa = parseTaskmarkId(a)

package/lib/taskmark/timing.ts

@@ -1,9 +1,13 @@
 import {
-  asNumberOrNull,
-} from "@/lib/taskmark/frontmatter"
+  cell,
+  extractMarkdownBody,
+  extractSections,
+  getSection,
+  parseMarkdownTable,
+  tableRowsAsObjects,
+} from "@/lib/taskmark/parse-sections"
 
 export type TimingFields = {
-  estimateMinutes: number | null
   /** Billable work-log minutes (floor of actual_ms / 60000). */
   actualMinutes: number | null
   /** Precise billable work-log duration in milliseconds. */
@@ -11,22 +15,29 @@ export type TimingFields = {
 }
 
 /**
- * Read estimate and actual from board frontmatter.
- * Est = optional/historical planned minutes (sizing no longer suggests time).
- * Actual = session time spent (prefers actual_ms; falls back to minutes / effort).
+ * Actual is the sum of closed Work log intervals stored on the leaf.
+ * Frontmatter timing fields are intentionally ignored.
  */
-export function readTimingFields(
-  frontmatter: Record<string, unknown>
-): TimingFields {
-  const actualMinutes =
-    asNumberOrNull(frontmatter.actual_minutes) ??
-    asNumberOrNull(frontmatter.effort_minutes)
-  const actualMs =
-    asNumberOrNull(frontmatter.actual_ms) ??
-    (actualMinutes != null ? actualMinutes * 60_000 : null)
+export function readActualTimingFromWorkLog(raw: string): TimingFields {
+  const sections = extractSections(extractMarkdownBody(raw))
+  const rows = tableRowsAsObjects(
+    parseMarkdownTable(getSection(sections, "Work log"))
+  )
+  let actualMs = 0
+  let hasClosedInterval = false
+
+  for (const row of rows) {
+    const started = Date.parse(cell(row, "started (utc)", "started"))
+    const ended = Date.parse(cell(row, "ended (utc)", "ended"))
+    if (!Number.isFinite(started) || !Number.isFinite(ended) || ended < started) {
+      continue
+    }
+    hasClosedInterval = true
+    actualMs += ended - started
+  }
+
   return {
-    estimateMinutes: asNumberOrNull(frontmatter.estimate_minutes),
-    actualMinutes,
-    actualMs,
+    actualMinutes: hasClosedInterval ? Math.floor(actualMs / 60_000) : null,
+    actualMs: hasClosedInterval ? actualMs : null,
   }
 }

package/lib/taskmark/validate.ts

@@ -64,7 +64,7 @@ export function validateMasterFolder(
       ok: false,
       code: "no_projects",
       error:
-        "No Taskmark projects found in subfolders. Look for a nested taskmark/ board (INDEX.md or epics/), or a dedicated *-taskmark folder with those files at its root.",
+        "No Taskmark projects found in subfolders. Look for a nested taskmark/epics/ board, or a dedicated *-taskmark folder with epics/ at its root.",
     }
   }
 

package/lib/theme-cookie.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import {
+  parseThemePreference,
+  themeCookieDomain,
+} from "./theme-cookie"
+
+test("accepts only light or dark cookie values", () => {
+  assert.equal(parseThemePreference("light"), "light")
+  assert.equal(parseThemePreference("dark"), "dark")
+  assert.equal(parseThemePreference("system"), undefined)
+  assert.equal(parseThemePreference(""), undefined)
+  assert.equal(parseThemePreference(undefined), undefined)
+})
+
+test("uses the parent domain on hosted Taskmark hosts", () => {
+  assert.equal(themeCookieDomain("taskmark.dev"), ".taskmark.dev")
+  assert.equal(themeCookieDomain("board.taskmark.dev"), ".taskmark.dev")
+  assert.equal(themeCookieDomain("www.taskmark.dev"), ".taskmark.dev")
+})
+
+test("omits Domain on localhost and unrelated hosts", () => {
+  assert.equal(themeCookieDomain("localhost"), undefined)
+  assert.equal(themeCookieDomain("127.0.0.1"), undefined)
+  assert.equal(themeCookieDomain("example.com"), undefined)
+})

package/lib/theme-cookie.ts

@@ -0,0 +1,43 @@
+export const THEME_COOKIE_NAME = "taskmark_theme"
+export const THEME_STORAGE_KEY = "taskmark_theme"
+export const THEME_COOKIE_MAX_AGE = 60 * 60 * 24 * 365
+export const THEME_COOKIE_PARENT_DOMAIN = ".taskmark.dev"
+
+export type ThemePreference = "light" | "dark"
+
+export function parseThemePreference(
+  value: string | null | undefined
+): ThemePreference | undefined {
+  if (value === "light" || value === "dark") return value
+  return undefined
+}
+
+/** Parent domain for hosted site + board; omit on localhost and other hosts. */
+export function themeCookieDomain(
+  hostname: string
+): string | undefined {
+  if (hostname === "taskmark.dev" || hostname.endsWith(".taskmark.dev")) {
+    return THEME_COOKIE_PARENT_DOMAIN
+  }
+  return undefined
+}
+
+export function writeThemeCookie(theme: ThemePreference): void {
+  if (typeof document === "undefined") return
+  const parts = [
+    `${THEME_COOKIE_NAME}=${theme}`,
+    "path=/",
+    `max-age=${THEME_COOKIE_MAX_AGE}`,
+    "SameSite=Lax",
+  ]
+  const domain = themeCookieDomain(window.location.hostname)
+  if (domain) parts.push(`domain=${domain}`)
+  if (window.location.protocol === "https:") parts.push("Secure")
+  document.cookie = parts.join("; ")
+}
+
+/**
+ * Runs before paint: cookie wins, else localStorage, else OS.
+ * Also copies a cookie preference into localStorage so next-themes agrees.
+ */
+export const THEME_INIT_SCRIPT = `(function(){try{var n=${JSON.stringify(THEME_COOKIE_NAME)};var k=${JSON.stringify(THEME_STORAGE_KEY)};var m=document.cookie.match(new RegExp("(?:^|; )"+n+"=([^;]*)"));var stored=m?decodeURIComponent(m[1]):null;function ok(v){return v==="light"||v==="dark"}if(!ok(stored)){stored=null;try{stored=localStorage.getItem(k);if(!ok(stored))stored=localStorage.getItem("theme")}catch(e){stored=null}if(!ok(stored))stored=null}if(ok(stored)){try{localStorage.setItem(k,stored)}catch(e){}}var dark=stored==="dark"||(stored!=="light"&&window.matchMedia("(prefers-color-scheme: dark)").matches);document.documentElement.classList.toggle("dark",dark);document.documentElement.style.colorScheme=dark?"dark":"light"}catch(e){}})();`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taskmark/ui",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "description": "Taskmark board UI — run globally for setup/project picker, or install in a board folder to open that board with `npx taskmark`",
   "private": false,
   "type": "module",
@@ -41,6 +41,7 @@
     "serve": "node ./bin/taskmark.js serve",
     "preview": "node ./bin/taskmark.js preview",
     "prepack": "npm run build",
+    "test": "tsx --test \"lib/**/*.test.ts\"",
     "lint": "eslint"
   },
   "dependencies": {
@@ -55,6 +56,7 @@
     "date-fns": "^4.4.0",
     "esbuild": "^0.25.0",
     "lucide-react": "^1.25.0",
+    "mermaid": "^11.17.2",
     "next": "16.2.10",
     "next-themes": "^0.4.6",
     "react": "19.2.4",