gsd-pi 2.57.0-dev.f22a903 → 2.58.0-dev.778d6ac

package/src/resources/extensions/gsd/tests/gsd-tools.test.ts

@@ -21,8 +21,10 @@ import {
 import {
   saveDecisionToDb,
   updateRequirementInDb,
+  saveRequirementToDb,
   saveArtifactToDb,
   nextDecisionId,
+  nextRequirementId,
 } from '../db-writer.ts';
 import type { Requirement } from '../types.ts';
 
@@ -160,18 +162,11 @@ describe('gsd-tools', () => {
       assert.ok(mdContent.includes('R001'), 'REQUIREMENTS.md should contain R001');
       assert.ok(mdContent.includes('validated'), 'REQUIREMENTS.md should reflect updated status');
 
-      // Updating non-existent requirement throws
-      let threwForMissing = false;
-      try {
-        await updateRequirementInDb('R999', { status: 'deferred' }, tmpDir);
-      } catch (err) {
-        threwForMissing = true;
-        assert.ok(
-          (err as Error).message.includes('R999'),
-          'Error should mention the missing requirement ID',
-        );
-      }
-      assert.ok(threwForMissing, 'Should throw for non-existent requirement');
+      // Updating non-existent requirement upserts (creates it) — see #2919
+      await updateRequirementInDb('R999', { status: 'deferred' }, tmpDir);
+      const upserted = getRequirementById('R999');
+      assert.ok(upserted !== null, 'R999 should be created by upsert');
+      assert.deepStrictEqual(upserted!.status, 'deferred', 'Upserted requirement should have the updated status');
 
       closeDatabase();
     } finally {
@@ -263,6 +258,124 @@ describe('gsd-tools', () => {
     assert.deepStrictEqual(fallbackId, 'D001', 'nextDecisionId should return D001 when DB unavailable');
   });
 
+  test('gsd_requirement_save creates new requirement', async () => {
+    const tmpDir = makeTmpDir();
+    try {
+      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+      openDatabase(dbPath);
+
+      // (a) saveRequirementToDb creates a new requirement with auto-assigned ID
+      const result = await saveRequirementToDb(
+        {
+          class: 'functional',
+          status: 'active',
+          description: 'Must support dark mode',
+          why: 'Accessibility requirement',
+          source: 'user-research',
+        },
+        tmpDir,
+      );
+
+      assert.deepStrictEqual(result.id, 'R001', 'First requirement should be R001');
+
+      // Verify DB row exists
+      const row = getRequirementById('R001');
+      assert.ok(row !== null, 'Requirement R001 should exist in DB');
+      assert.deepStrictEqual(row!.class, 'functional', 'Class should match');
+      assert.deepStrictEqual(row!.description, 'Must support dark mode', 'Description should match');
+      assert.deepStrictEqual(row!.status, 'active', 'Status should match');
+
+      // Verify REQUIREMENTS.md was generated
+      const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
+      assert.ok(fs.existsSync(mdPath), 'REQUIREMENTS.md should be created');
+      const mdContent = fs.readFileSync(mdPath, 'utf-8');
+      assert.ok(mdContent.includes('R001'), 'REQUIREMENTS.md should contain R001');
+      assert.ok(mdContent.includes('dark mode'), 'REQUIREMENTS.md should contain description');
+
+      // (b) Auto-assigns correct next ID
+      const result2 = await saveRequirementToDb(
+        {
+          class: 'non-functional',
+          status: 'active',
+          description: 'Must load in under 2 seconds',
+          why: 'Performance SLA',
+          source: 'design',
+        },
+        tmpDir,
+      );
+      assert.deepStrictEqual(result2.id, 'R002', 'Second requirement should be R002');
+
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
+
+  test('nextRequirementId computes correct next ID', async () => {
+    const tmpDir = makeTmpDir();
+    try {
+      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+      openDatabase(dbPath);
+
+      // No requirements yet
+      const id1 = await nextRequirementId();
+      assert.deepStrictEqual(id1, 'R001', 'Should return R001 when no requirements exist');
+
+      // Add one requirement
+      upsertRequirement({
+        id: 'R001',
+        class: 'functional',
+        status: 'active',
+        description: 'Test',
+        why: '',
+        source: '',
+        primary_owner: '',
+        supporting_slices: '',
+        validation: '',
+        notes: '',
+        full_content: '',
+        superseded_by: null,
+      });
+
+      const id2 = await nextRequirementId();
+      assert.deepStrictEqual(id2, 'R002', 'Should return R002 after R001 exists');
+
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
+
+  test('gsd_requirement_update upserts when requirement not in DB', async () => {
+    const tmpDir = makeTmpDir();
+    try {
+      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+      openDatabase(dbPath);
+
+      // Requirement R025 does NOT exist in DB — simulates the bug scenario
+      // where requirements exist in REQUIREMENTS.md but were never imported.
+      // updateRequirementInDb should create the row instead of throwing.
+      await updateRequirementInDb(
+        'R025',
+        { status: 'validated', validation: 'Integration tests pass' },
+        tmpDir,
+      );
+
+      const created = getRequirementById('R025');
+      assert.ok(created !== null, 'R025 should be created by upsert');
+      assert.deepStrictEqual(created!.status, 'validated', 'Status should be set');
+      assert.deepStrictEqual(created!.validation, 'Integration tests pass', 'Validation should be set');
+
+      // Verify REQUIREMENTS.md was generated
+      const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
+      assert.ok(fs.existsSync(mdPath), 'REQUIREMENTS.md should be created');
+
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
+
   test('Tool result format', async () => {
     const tmpDir = makeTmpDir();
     try {

package/src/resources/extensions/gsd/tests/gsdroot-worktree-detection.test.ts

@@ -0,0 +1,164 @@
+/**
+ * gsdroot-worktree-detection.test.ts — Regression test for #2594.
+ *
+ * gsdRoot() must return the worktree's own .gsd directory when the basePath
+ * is inside a .gsd/worktrees/<name>/ structure, not walk up to the project
+ * root's .gsd via the git-root probe.
+ *
+ * The bug: when a git worktree lives at /project/.gsd/worktrees/M008/,
+ * probeGsdRoot() runs `git rev-parse --show-toplevel` which can return the
+ * main project root (not the worktree root) depending on git version and
+ * worktree setup. The walk-up then finds /project/.gsd and returns that
+ * instead of the worktree's own .gsd path.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { mkdtempSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+
+import { gsdRoot, _clearGsdRootCache } from "../paths.ts";
+
+describe("gsdRoot() worktree detection (#2594)", () => {
+  let projectRoot: string;
+  let projectGsd: string;
+
+  beforeEach(() => {
+    _clearGsdRootCache();
+    // Create a temporary project with a git repo to simulate real conditions.
+    // realpathSync handles macOS /tmp -> /private/tmp.
+    projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsdroot-wt-")));
+    projectGsd = join(projectRoot, ".gsd");
+    mkdirSync(projectGsd, { recursive: true });
+
+    // Initialize a git repo in the project root so git rev-parse works
+    spawnSync("git", ["init", "--initial-branch=main"], {
+      cwd: projectRoot,
+      stdio: "ignore",
+    });
+    spawnSync("git", ["config", "user.email", "test@test.com"], {
+      cwd: projectRoot,
+      stdio: "ignore",
+    });
+    spawnSync("git", ["config", "user.name", "Test"], {
+      cwd: projectRoot,
+      stdio: "ignore",
+    });
+    // Create an initial commit so we have a HEAD
+    writeFileSync(join(projectRoot, "README.md"), "# Test");
+    spawnSync("git", ["add", "."], { cwd: projectRoot, stdio: "ignore" });
+    spawnSync("git", ["commit", "-m", "init"], {
+      cwd: projectRoot,
+      stdio: "ignore",
+    });
+  });
+
+  afterEach(() => {
+    _clearGsdRootCache();
+    rmSync(projectRoot, { recursive: true, force: true });
+  });
+
+  test("returns worktree .gsd when basePath is a worktree with its own .gsd (fast path)", () => {
+    // Simulates a worktree that already had copyPlanningArtifacts() run,
+    // so it has its own .gsd/ directory.
+    const worktreeBase = join(projectGsd, "worktrees", "M008");
+    const worktreeGsd = join(worktreeBase, ".gsd");
+    mkdirSync(worktreeGsd, { recursive: true });
+
+    const result = gsdRoot(worktreeBase);
+    assert.equal(
+      result,
+      worktreeGsd,
+      `Expected worktree .gsd (${worktreeGsd}), got ${result}. ` +
+        "gsdRoot() should use the fast path for an existing worktree .gsd.",
+    );
+  });
+
+  test("returns worktree .gsd path (not project root .gsd) when worktree .gsd does not exist yet", () => {
+    // This is the core #2594 bug: the worktree directory exists but its .gsd
+    // subdirectory hasn't been created yet. Without the fix, probeGsdRoot()
+    // walks up from the worktree path, finds /project/.gsd, and returns it.
+    // With the fix, it detects the .gsd/worktrees/<name>/ pattern and returns
+    // the worktree-local .gsd path as the creation fallback.
+    const worktreeBase = join(projectGsd, "worktrees", "M008");
+    mkdirSync(worktreeBase, { recursive: true });
+    // NOTE: no .gsd/ inside worktreeBase
+
+    const result = gsdRoot(worktreeBase);
+    const expected = join(worktreeBase, ".gsd");
+
+    // Without the fix, this returns projectGsd (/project/.gsd) because the
+    // walk-up from worktreeBase finds it. With the fix, it returns the
+    // worktree-local path.
+    assert.notEqual(
+      result,
+      projectGsd,
+      "gsdRoot() must NOT return the project root .gsd when basePath is inside .gsd/worktrees/",
+    );
+    assert.equal(
+      result,
+      expected,
+      `Expected worktree-local .gsd (${expected}), got ${result}.`,
+    );
+  });
+
+  test("returns worktree .gsd when basePath is a real git worktree inside .gsd/worktrees/", () => {
+    // Create a real git worktree at .gsd/worktrees/M010
+    const worktreeName = "M010";
+    const worktreeBase = join(projectGsd, "worktrees", worktreeName);
+
+    // Use git worktree add to create a real worktree
+    const result = spawnSync(
+      "git",
+      ["worktree", "add", "-b", `milestone/${worktreeName}`, worktreeBase],
+      { cwd: projectRoot, encoding: "utf-8" },
+    );
+
+    if (result.status !== 0) {
+      // If git worktree add fails, skip the test gracefully
+      assert.ok(true, "Skipped: git worktree add not available");
+      return;
+    }
+
+    // The real git worktree exists at worktreeBase but has NO .gsd/ subdir yet
+    const gsdResult = gsdRoot(worktreeBase);
+    const expected = join(worktreeBase, ".gsd");
+
+    assert.notEqual(
+      gsdResult,
+      projectGsd,
+      "gsdRoot() must NOT escape to project root .gsd from inside a git worktree",
+    );
+    assert.equal(
+      gsdResult,
+      expected,
+      `Expected worktree-local .gsd (${expected}), got ${gsdResult}`,
+    );
+
+    // Cleanup worktree
+    spawnSync("git", ["worktree", "remove", "--force", worktreeBase], {
+      cwd: projectRoot,
+      stdio: "ignore",
+    });
+  });
+
+  test("still returns project .gsd for normal (non-worktree) basePath", () => {
+    const result = gsdRoot(projectRoot);
+    assert.equal(result, projectGsd);
+  });
+
+  test("still returns project .gsd for a subdirectory of the project", () => {
+    const subdir = join(projectRoot, "src", "lib");
+    mkdirSync(subdir, { recursive: true });
+
+    const result = gsdRoot(subdir);
+    assert.equal(
+      result,
+      projectGsd,
+      "Non-worktree subdirectories should still resolve to project .gsd",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/guided-flow-dynamic-routing.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Guided-flow dynamic routing — regression test for #2958.
+ *
+ * Verifies that dispatchWorkflow() routes through the dynamic routing pipeline
+ * (selectAndApplyModel from auto-model-selection.ts) instead of bypassing it
+ * with a direct call to resolveModelWithFallbacksForUnit.
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+function readSrc(file: string): string {
+  return readFileSync(join(gsdDir, file), "utf-8");
+}
+
+const guidedFlowSrc = readSrc("guided-flow.ts");
+
+// ═══════════════════════════════════════════════════════════════════════════
+// #2958: dispatchWorkflow must route through dynamic routing pipeline
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("#2958: guided-flow imports selectAndApplyModel from auto-model-selection", () => {
+  assert.ok(
+    guidedFlowSrc.includes("selectAndApplyModel"),
+    "guided-flow.ts must import and use selectAndApplyModel from auto-model-selection.ts",
+  );
+});
+
+test("#2958: dispatchWorkflow does not call resolveModelWithFallbacksForUnit directly", () => {
+  // Extract the dispatchWorkflow function body
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
+
+  // Find the function body by tracking brace depth
+  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+  let depth = 1;
+  let pos = openBrace + 1;
+  while (depth > 0 && pos < guidedFlowSrc.length) {
+    if (guidedFlowSrc[pos] === "{") depth++;
+    else if (guidedFlowSrc[pos] === "}") depth--;
+    pos++;
+  }
+  const fnBody = guidedFlowSrc.slice(openBrace, pos);
+
+  assert.ok(
+    !fnBody.includes("resolveModelWithFallbacksForUnit"),
+    "dispatchWorkflow must NOT call resolveModelWithFallbacksForUnit directly — " +
+    "it must route through selectAndApplyModel for dynamic routing support (#2958)",
+  );
+});
+
+test("#2958: dispatchWorkflow calls selectAndApplyModel for model selection", () => {
+  // Extract the dispatchWorkflow function body
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
+
+  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+  let depth = 1;
+  let pos = openBrace + 1;
+  while (depth > 0 && pos < guidedFlowSrc.length) {
+    if (guidedFlowSrc[pos] === "{") depth++;
+    else if (guidedFlowSrc[pos] === "}") depth--;
+    pos++;
+  }
+  const fnBody = guidedFlowSrc.slice(openBrace, pos);
+
+  assert.ok(
+    fnBody.includes("selectAndApplyModel"),
+    "dispatchWorkflow must call selectAndApplyModel to route through the dynamic routing pipeline (#2958)",
+  );
+});
+
+test("#2958: dispatchWorkflow does not use resolveAvailableModel inline", () => {
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
+
+  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+  let depth = 1;
+  let pos = openBrace + 1;
+  while (depth > 0 && pos < guidedFlowSrc.length) {
+    if (guidedFlowSrc[pos] === "{") depth++;
+    else if (guidedFlowSrc[pos] === "}") depth--;
+    pos++;
+  }
+  const fnBody = guidedFlowSrc.slice(openBrace, pos);
+
+  assert.ok(
+    !fnBody.includes("resolveAvailableModel"),
+    "dispatchWorkflow must NOT use resolveAvailableModel inline — " +
+    "model resolution is handled by selectAndApplyModel (#2958)",
+  );
+});
+
+test("#2958: guided-flow does not import resolveModelWithFallbacksForUnit", () => {
+  // The import should be removed since dispatchWorkflow was the only consumer
+  // Check if resolveModelWithFallbacksForUnit is still used elsewhere in the file
+  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
+  const beforeDispatch = guidedFlowSrc.slice(0, fnStart);
+  const afterFnEnd = (() => {
+    const openBrace = guidedFlowSrc.indexOf("{", fnStart);
+    let depth = 1;
+    let p = openBrace + 1;
+    while (depth > 0 && p < guidedFlowSrc.length) {
+      if (guidedFlowSrc[p] === "{") depth++;
+      else if (guidedFlowSrc[p] === "}") depth--;
+      p++;
+    }
+    return guidedFlowSrc.slice(p);
+  })();
+
+  // If resolveModelWithFallbacksForUnit is not used outside dispatchWorkflow,
+  // the import should be removed
+  const usedOutside = beforeDispatch.includes("resolveModelWithFallbacksForUnit(")
+    || afterFnEnd.includes("resolveModelWithFallbacksForUnit(");
+
+  if (!usedOutside) {
+    // Verify the import line was cleaned up
+    const importLines = guidedFlowSrc.split("\n").filter(l =>
+      l.includes("import") && l.includes("resolveModelWithFallbacksForUnit"),
+    );
+    assert.equal(
+      importLines.length,
+      0,
+      "resolveModelWithFallbacksForUnit import should be removed when no longer used outside dispatchWorkflow",
+    );
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Regression test for #2985 Bugs 3 & 4:
+ *   Bug 3 — module-level pendingAutoStart singleton clobbers concurrent sessions.
+ *   Bug 4 — getDiscussionMilestoneId() returns wrong project's milestone under concurrency.
+ *
+ * pendingAutoStart must be keyed by basePath so concurrent discuss sessions
+ * in different projects are independent.  getDiscussionMilestoneId() must accept
+ * a basePath parameter to perform a keyed lookup.
+ */
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  getDiscussionMilestoneId,
+  setPendingAutoStart,
+  clearPendingAutoStart,
+} from "../guided-flow.ts";
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+  });
+
+  test("second session does not clobber first session's pending auto-start", () => {
+    // Simulate two concurrent discuss sessions for different projects
+    const projectA = "/projects/alpha";
+    const projectB = "/projects/beta";
+
+    setPendingAutoStart(projectA, {
+      basePath: projectA,
+      milestoneId: "M001-aaa111",
+    });
+
+    setPendingAutoStart(projectB, {
+      basePath: projectB,
+      milestoneId: "M002-bbb222",
+    });
+
+    // Both sessions should be retrievable
+    const milestoneA = getDiscussionMilestoneId(projectA);
+    const milestoneB = getDiscussionMilestoneId(projectB);
+
+    assert.equal(milestoneA, "M001-aaa111", "projectA's milestone should be preserved");
+    assert.equal(milestoneB, "M002-bbb222", "projectB's milestone should be preserved");
+  });
+
+  test("clearing one session does not affect the other", () => {
+    const projectA = "/projects/alpha";
+    const projectB = "/projects/beta";
+
+    setPendingAutoStart(projectA, { basePath: projectA, milestoneId: "M001-aaa111" });
+    setPendingAutoStart(projectB, { basePath: projectB, milestoneId: "M002-bbb222" });
+
+    // Clear only projectA
+    clearPendingAutoStart(projectA);
+
+    assert.equal(getDiscussionMilestoneId(projectA), null, "projectA should be cleared");
+    assert.equal(getDiscussionMilestoneId(projectB), "M002-bbb222", "projectB should survive");
+  });
+});
+
+describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+  });
+
+  test("getDiscussionMilestoneId(basePath) returns correct milestone for each project", () => {
+    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+
+    assert.equal(getDiscussionMilestoneId("/proj/a"), "M001");
+    assert.equal(getDiscussionMilestoneId("/proj/b"), "M002");
+    assert.equal(getDiscussionMilestoneId("/proj/unknown"), null);
+  });
+
+  test("getDiscussionMilestoneId() without basePath returns null when multiple sessions exist", () => {
+    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+
+    // Without a key, the function should not blindly return the first entry
+    const result = getDiscussionMilestoneId();
+    // When there's ambiguity (multiple sessions), it should return null
+    // to force callers to be explicit
+    assert.equal(result, null, "should not return arbitrary milestone when multiple sessions exist");
+  });
+
+  test("getDiscussionMilestoneId() without basePath returns the milestone when only one session", () => {
+    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+
+    // With only one session, backward compat — return it
+    const result = getDiscussionMilestoneId();
+    assert.equal(result, "M001", "should return the only active milestone for backward compat");
+  });
+});

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 import {
   buildHealthLines,
   detectHealthWidgetProjectState,
+  formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
 
@@ -34,6 +35,8 @@ function activeData(overrides: Partial<HealthWidgetData> = {}): HealthWidgetData
     providerIssue: null,
     environmentErrorCount: 0,
     environmentWarningCount: 0,
+    lastCommitEpoch: null,
+    lastCommitMessage: null,
     lastRefreshed: Date.now(),
     ...overrides,
   };
@@ -98,6 +101,70 @@ test("buildHealthLines: active state with issues reports issue summary", (t) =>
   assert.match(lines[0]!, /Env: 1 error/);
 });
 
+// ── Last commit display ──────────────────────────────────────────────────
+
+test("buildHealthLines: shows last commit with relative time and message", (t) => {
+  const epoch = Math.floor(Date.now() / 1000) - 300; // 5 minutes ago
+  const lines = buildHealthLines(activeData({
+    lastCommitEpoch: epoch,
+    lastCommitMessage: "feat(widget): add health display",
+  }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /Last commit: 5m ago/);
+  assert.match(lines[0]!, /feat\(widget\): add health display/);
+});
+
+test("buildHealthLines: truncates long commit messages", (t) => {
+  const epoch = Math.floor(Date.now() / 1000) - 60;
+  const longMsg = "a".repeat(80);
+  const lines = buildHealthLines(activeData({
+    lastCommitEpoch: epoch,
+    lastCommitMessage: longMsg,
+  }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /a{49}…/);
+  assert.ok(!lines[0]!.includes("a".repeat(51)), "message is truncated");
+});
+
+test("buildHealthLines: no last commit section when epoch is null", (t) => {
+  const lines = buildHealthLines(activeData({ lastCommitEpoch: null }));
+  assert.equal(lines.length, 1);
+  assert.ok(!lines[0]!.includes("Last commit"), "no last commit when null");
+});
+
+test("buildHealthLines: last commit without message shows only time", (t) => {
+  const epoch = Math.floor(Date.now() / 1000) - 3600; // 1 hour ago
+  const lines = buildHealthLines(activeData({
+    lastCommitEpoch: epoch,
+    lastCommitMessage: null,
+  }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /Last commit: 1h ago/);
+  assert.ok(!lines[0]!.includes(" — "), "no dash separator when no message");
+});
+
+// ── formatRelativeTime ───────────────────────────────────────────────────
+
+test("formatRelativeTime: just now for <60s", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 30;
+  assert.equal(formatRelativeTime(epoch), "just now");
+});
+
+test("formatRelativeTime: minutes", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 300;
+  assert.equal(formatRelativeTime(epoch), "5m ago");
+});
+
+test("formatRelativeTime: hours", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 7200;
+  assert.equal(formatRelativeTime(epoch), "2h ago");
+});
+
+test("formatRelativeTime: days", () => {
+  const epoch = Math.floor(Date.now() / 1000) - 172800;
+  assert.equal(formatRelativeTime(epoch), "2d ago");
+});
+
 test("detectHealthWidgetProjectState: metrics file alone does not imply project", (t) => {
   const dir = makeTempDir("metrics-only");
   t.after(() => { cleanup(dir); });