@dsdenes/devboard 0.1.560 → 0.1.562

package/client/lib/notification-issue.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import type { AppNotification } from "./notifications.svelte";
+import { MAX_NOTIFICATION_REPORT, notificationReport } from "./notification-issue";
+
+function notification(overrides: Partial<AppNotification> = {}): AppNotification {
+  return {
+    id: 1,
+    severity: "error",
+    text: 'item 1 ("Flow restore re-adds checkpoints.jsonl entries") evidence: server/flow.ts does not exist',
+    at: "2026-10-28T11:29:44.932Z",
+    ...overrides,
+  };
+}
+
+describe("notification issue report", () => {
+  test("leads with the severity and notification text for the issue title", () => {
+    const report = notificationReport(notification());
+    expect(report.split("\n")[0]).toBe(
+      'Error notification: item 1 ("Flow restore re-adds checkpoints.jsonl entries") evidence: server/flow.ts does not exist',
+    );
+    expect(report).toContain("\n\nRaised at: 2026-10-28T11:29:44.932Z");
+  });
+
+  test("labels every severity without changing the notification text", () => {
+    expect(
+      notificationReport(notification({ severity: "warning" })).startsWith(
+        "Warning notification: ",
+      ),
+    ).toBe(true);
+    expect(
+      notificationReport(notification({ severity: "notice" })).startsWith(
+        "Notice notification: ",
+      ),
+    ).toBe(true);
+    expect(
+      notificationReport(notification({ severity: "success" })).startsWith(
+        "Success notification: ",
+      ),
+    ).toBe(true);
+  });
+
+  test("trims surrounding whitespace and keeps a long message inside the server bound", () => {
+    const long = notification({ text: `  ${"x".repeat(MAX_NOTIFICATION_REPORT)}  ` });
+    const report = notificationReport(long);
+    expect(report.length).toBeLessThanOrEqual(MAX_NOTIFICATION_REPORT);
+    expect(report.endsWith("…\n\nRaised at: 2026-10-28T11:29:44.932Z")).toBe(true);
+  });
+
+  test("a long first line is truncated without losing the timestamp", () => {
+    const report = notificationReport(notification({ text: "y".repeat(10_000) }));
+    expect(report.split("\n")[0]!.length).toBeLessThanOrEqual(MAX_NOTIFICATION_REPORT);
+  });
+});

package/client/lib/notification-issue.ts

@@ -0,0 +1,27 @@
+import type { AppNotification, Severity } from "./notifications.svelte";
+
+/** The server's `report` bound; the title line and metadata must fit inside it. */
+export const MAX_NOTIFICATION_REPORT = 8000;
+
+const SEVERITY_LABEL: Record<Severity, string> = {
+  error: "Error",
+  warning: "Warning",
+  notice: "Notice",
+  success: "Success",
+};
+
+/**
+ * The report a notification button files. Its first line becomes the issue
+ * title, so the notification text leads, labelled with its severity; the
+ * timestamp follows as context. The whole report stays inside the server's
+ * bound even for a long server message.
+ */
+export function notificationReport(item: AppNotification): string {
+  const prefix = `${SEVERITY_LABEL[item.severity]} notification: `;
+  const suffix = `\n\nRaised at: ${item.at}`;
+  const budget = Math.max(0, MAX_NOTIFICATION_REPORT - prefix.length - suffix.length);
+  const text = item.text.trim();
+  const body =
+    text.length <= budget ? text : `${text.slice(0, Math.max(0, budget - 1)).trimEnd()}…`;
+  return `${prefix}${body}${suffix}`;
+}

package/client/lib/notifications.svelte.ts

@@ -0,0 +1,62 @@
+export type Severity = "error" | "warning" | "notice" | "success";
+
+export interface AppNotification {
+  id: number;
+  severity: Severity;
+  text: string;
+  at: string;
+}
+
+const HISTORY_LIMIT = 200;
+
+/**
+ * Server errors, notices, and client connection failures. The newest entries
+ * render in the live notification region; every entry stays in the history
+ * opened from the status bar.
+ */
+export class NotificationStore {
+  items = $state<AppNotification[]>([]);
+  unread = $state(0);
+  historyOpen = $state(false);
+  private counter = 0;
+
+  push(severity: Severity, text: string): void {
+    const message = text.trim();
+    if (message.length === 0) return;
+    this.counter += 1;
+    this.items = [
+      {
+        id: this.counter,
+        severity,
+        text: message,
+        at: new Date().toISOString(),
+      },
+      ...this.items,
+    ].slice(0, HISTORY_LIMIT);
+    this.unread += 1;
+  }
+
+  dismiss(id: number): void {
+    this.items = this.items.filter((item) => item.id !== id);
+  }
+
+  clear(): void {
+    this.items = [];
+    this.unread = 0;
+  }
+
+  markRead(): void {
+    this.unread = 0;
+  }
+
+  openHistory(): void {
+    this.historyOpen = true;
+    this.markRead();
+  }
+
+  closeHistory(): void {
+    this.historyOpen = false;
+  }
+}
+
+export const notifications = new NotificationStore();

package/client/lib/poll-status.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+import type { IssuesSnapshot } from "./types";
+import { pollAge, pollInterval, pollStatus } from "./poll-status";
+
+const AT = Date.parse("2026-10-27T14:03:24.000Z");
+
+function snapshot(overrides: Partial<IssuesSnapshot> = {}): IssuesSnapshot {
+  return {
+    present: true,
+    repo: "fixture/host",
+    root: "/fixture",
+    lifecycle: "running",
+    enabled: true,
+    paused: false,
+    attached: true,
+    worker: null,
+    poll: {
+      intervalMs: 2_000,
+      lastPollAt: "2026-10-27T14:03:22.854Z",
+      nextPollAt: "2026-10-27T14:03:24.854Z",
+      etag: '"etag"',
+      notModified: false,
+      rateLimitedUntil: null,
+      error: null,
+    },
+    queue: [],
+    runs: [],
+    agents: [],
+    cooldowns: {},
+    lastError: null,
+    lastExitCode: null,
+    finishedAt: null,
+    notice: null,
+    updatedAt: null,
+    ...overrides,
+  };
+}
+
+describe("poll interval", () => {
+  test("keeps sub-second cadences in milliseconds and whole seconds unrounded", () => {
+    expect(pollInterval(250)).toBe("250ms");
+    expect(pollInterval(2_000)).toBe("2s");
+    expect(pollInterval(60_000)).toBe("60s");
+  });
+
+  test("rounds a fractional cadence to one decimal", () => {
+    expect(pollInterval(1_500)).toBe("1.5s");
+    expect(pollInterval(1_333)).toBe("1.3s");
+  });
+
+  test("does not invent a cadence for an invalid interval", () => {
+    expect(pollInterval(0)).toBe("unknown");
+    expect(pollInterval(Number.NaN)).toBe("unknown");
+  });
+});
+
+describe("poll age", () => {
+  test("reads seconds, minutes, hours, and days at polling resolution", () => {
+    expect(pollAge("2026-10-27T14:03:23.500Z", AT)).toBe("just now");
+    expect(pollAge("2026-10-27T14:03:22.854Z", AT)).toBe("1s ago");
+    expect(pollAge("2026-10-27T13:58:24.000Z", AT)).toBe("5m ago");
+    expect(pollAge("2026-10-27T11:03:24.000Z", AT)).toBe("3h ago");
+    expect(pollAge("2026-10-24T14:03:24.000Z", AT)).toBe("3d ago");
+  });
+
+  test("clamps a future timestamp and names an unreadable one", () => {
+    expect(pollAge("2026-10-27T14:04:00.000Z", AT)).toBe("just now");
+    expect(pollAge("not a date", AT)).toBe("at an unknown time");
+  });
+});
+
+describe("poll status", () => {
+  test("states the cadence and the last check while polling", () => {
+    const status = pollStatus(snapshot(), AT);
+    expect(status).toEqual({
+      tone: "active",
+      text: "Every 2s · checked 1s ago",
+      title:
+        "Poll interval 2s · last check 2026-10-27T14:03:22.854Z · next check 2026-10-27T14:03:24.854Z",
+    });
+  });
+
+  test("reads a stopped or paused worker as not polling", () => {
+    expect(pollStatus(null, AT)).toMatchObject({ tone: "idle", text: "Not polling" });
+    expect(pollStatus(snapshot({ lifecycle: "stopped", enabled: false }), AT)).toMatchObject({
+      tone: "idle",
+      text: "Not polling",
+    });
+    expect(pollStatus(snapshot({ lifecycle: "paused", paused: true }), AT)).toMatchObject({
+      tone: "idle",
+      text: "Polling paused",
+    });
+    expect(pollStatus(snapshot({ lifecycle: "pausing" }), AT)).toMatchObject({ text: "Polling paused" });
+  });
+
+  test("names a failing poll without losing the last check", () => {
+    const poll = snapshot().poll;
+    if (poll === null) throw new Error("fixture poll missing");
+    const status = pollStatus(snapshot({ poll: { ...poll, error: "HTTP 502" } }), AT);
+    expect(status).toMatchObject({ tone: "failed", text: "Poll failing · checked 1s ago" });
+  });
+
+  test("names a rate limit only while it is still in effect", () => {
+    const poll = snapshot().poll;
+    if (poll === null) throw new Error("fixture poll missing");
+    const limited = pollStatus(
+      snapshot({ poll: { ...poll, error: "slow down", rateLimitedUntil: "2026-10-27T14:04:00.000Z" } }),
+      AT,
+    );
+    expect(limited).toMatchObject({ tone: "limited", text: "Rate limited · checked 1s ago" });
+
+    const expired = pollStatus(
+      snapshot({ poll: { ...poll, error: "slow down", rateLimitedUntil: "2026-10-27T14:03:00.000Z" } }),
+      AT,
+    );
+    expect(expired).toMatchObject({ tone: "failed", text: "Poll failing · checked 1s ago" });
+  });
+
+  test("names an overdue check instead of claiming a live loop", () => {
+    const poll = snapshot().poll;
+    if (poll === null) throw new Error("fixture poll missing");
+    expect(
+      pollStatus(snapshot({ poll: { ...poll, lastPollAt: "2026-10-27T09:03:24.000Z" } }), AT),
+    ).toMatchObject({ tone: "stale", text: "Check overdue · checked 5h ago" });
+  });
+
+  test("states the first check before one has finished", () => {
+    const poll = snapshot().poll;
+    if (poll === null) throw new Error("fixture poll missing");
+    expect(pollStatus(snapshot({ poll: { ...poll, lastPollAt: null } }), AT)).toMatchObject({
+      text: "Every 2s · no check yet",
+    });
+  });
+
+  test("states a worker that has not published a poll yet", () => {
+    expect(pollStatus(snapshot({ poll: null }), AT)).toMatchObject({
+      tone: "idle",
+      text: "Starting up",
+    });
+  });
+});

package/client/lib/poll-status.ts

@@ -0,0 +1,88 @@
+import type { IssuesSnapshot } from "./types";
+
+/**
+ * The visual state of the Automation panel's poll line. The word in the text
+ * always carries the meaning; `tone` only colors the dot.
+ */
+export type PollTone = "active" | "stale" | "limited" | "failed" | "idle";
+
+export interface PollStatus {
+  tone: PollTone;
+  text: string;
+  title: string;
+}
+
+const SECOND = 1_000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+
+/** Poll cadence as a short duration: `500ms`, `2s`, `1.5s`, `60s`. */
+export function pollInterval(intervalMs: number): string {
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) return "unknown";
+  if (intervalMs < SECOND) return `${Math.round(intervalMs)}ms`;
+  const seconds = intervalMs / SECOND;
+  return `${Number.isInteger(seconds) ? seconds : Math.round(seconds * 10) / 10}s`;
+}
+
+/**
+ * How long ago a poll finished, at the resolution polling actually needs:
+ * seconds below a minute, then minutes, hours, and days. A timestamp in the
+ * future (clock skew) reads `just now` rather than a negative duration.
+ */
+export function pollAge(value: string, now: number): string {
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) return "at an unknown time";
+  const elapsed = Math.max(0, now - timestamp);
+  if (elapsed < SECOND) return "just now";
+  if (elapsed < MINUTE) return `${Math.floor(elapsed / SECOND)}s ago`;
+  if (elapsed < HOUR) return `${Math.floor(elapsed / MINUTE)}m ago`;
+  if (elapsed < DAY) return `${Math.floor(elapsed / HOUR)}h ago`;
+  return `${Math.floor(elapsed / DAY)}d ago`;
+}
+
+/**
+ * The Automation panel subtitle. It states whether the worker is polling, how
+ * often, and when it last checked; the exact timestamps stay in the tooltip so
+ * a precise time is one hover away without cluttering the header.
+ */
+export function pollStatus(snapshot: IssuesSnapshot | null, now: number): PollStatus {
+  const poll = snapshot?.poll ?? null;
+  const interval = poll === null ? "unknown" : pollInterval(poll.intervalMs);
+  const last = poll?.lastPollAt ?? null;
+  const next = poll?.nextPollAt ?? null;
+  const title = [
+    `Poll interval ${interval}`,
+    `last check ${last ?? "never"}`,
+    `next check ${next ?? "not scheduled"}`,
+  ].join(" · ");
+
+  if (snapshot === null || !snapshot.present || !snapshot.enabled || snapshot.lifecycle === "stopped") {
+    return { tone: "idle", text: "Not polling", title: "The issues worker is stopped." };
+  }
+
+  if (snapshot.paused || snapshot.lifecycle === "paused" || snapshot.lifecycle === "pausing") {
+    return { tone: "idle", text: "Polling paused", title };
+  }
+
+  if (poll === null) {
+    return { tone: "idle", text: "Starting up", title: "The issues worker has not reported a poll yet." };
+  }
+
+  const checked = last === null ? "no check yet" : `checked ${pollAge(last, now)}`;
+  const limited = poll.rateLimitedUntil !== null && Date.parse(poll.rateLimitedUntil) > now;
+
+  if (limited) {
+    return { tone: "limited", text: `Rate limited · ${checked}`, title };
+  }
+  if (poll.error !== null) {
+    return { tone: "failed", text: `Poll failing · ${checked}`, title };
+  }
+  const lastAt = last === null ? null : Date.parse(last);
+  const overdue =
+    lastAt !== null && !Number.isNaN(lastAt) && now - lastAt > Math.max(3 * poll.intervalMs, 10 * SECOND);
+  if (overdue) {
+    return { tone: "stale", text: `Check overdue · ${checked}`, title };
+  }
+  return { tone: "active", text: `Every ${interval} · ${checked}`, title };
+}

package/client/lib/record-status.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { recordStatusTone } from "./record-status";
+
+describe("record status tone", () => {
+  test("maps each decision status to its badge tone", () => {
+    expect(recordStatusTone("Accepted")).toBe("success");
+    expect(recordStatusTone(" accepted ")).toBe("success");
+    expect(recordStatusTone("Draft")).toBe("pending");
+    expect(recordStatusTone("Proposed")).toBe("pending");
+    expect(recordStatusTone("Superseded")).toBe("stale");
+    expect(recordStatusTone("Deprecated")).toBe("stale");
+    expect(recordStatusTone("Rejected")).toBe("error");
+  });
+
+  test("leaves a status it does not know neutral", () => {
+    expect(recordStatusTone("")).toBeUndefined();
+    expect(recordStatusTone("Deferred")).toBeUndefined();
+  });
+});

package/client/lib/record-status.ts

@@ -0,0 +1,25 @@
+/** Badge tones `app.css` styles for `.badge[data-tone]`. */
+export type BadgeTone = "pending" | "success" | "warning" | "error" | "accent" | "stale";
+
+/**
+ * The tone one decision record's status earns. A record's `status` is the
+ * frontmatter value rendered with a capital first letter, so the mapping is on
+ * the normalized word; an unrecognized status keeps the neutral badge rather
+ * than guessing.
+ */
+export function recordStatusTone(status: string): BadgeTone | undefined {
+  switch (status.trim().toLowerCase()) {
+    case "accepted":
+      return "success";
+    case "draft":
+    case "proposed":
+      return "pending";
+    case "superseded":
+    case "deprecated":
+      return "stale";
+    case "rejected":
+      return "error";
+    default:
+      return undefined;
+  }
+}

package/client/lib/scout.svelte.ts

@@ -0,0 +1,164 @@
+import { connection } from "./connection.svelte";
+import { notifications } from "./notifications.svelte";
+import type {
+  ScoutActivityEntry,
+  ScoutIssueRow,
+  ScoutLimits,
+  ScoutSnapshot,
+  ScoutSync,
+} from "./types";
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isSnapshot(value: Record<string, unknown>): boolean {
+  return (
+    value.type === "scoutState" &&
+    typeof value.root === "string" &&
+    typeof value.lifecycle === "string" &&
+    typeof value.enabled === "boolean" &&
+    Array.isArray(value.issues) &&
+    isObject(value.sync) &&
+    isObject(value.limits)
+  );
+}
+
+function isEntry(value: unknown): value is ScoutActivityEntry {
+  return isObject(value) && typeof value.text === "string" && typeof value.append === "boolean";
+}
+
+function applyActivity(lines: string[], entries: ScoutActivityEntry[], replay: boolean): string[] {
+  const next = replay ? [] : [...lines];
+  for (const entry of entries) {
+    if (entry.append && next.length > 0) next[next.length - 1] += entry.text;
+    else next.push(entry.text);
+  }
+  return next;
+}
+
+const DEFAULT_LIMITS: ScoutLimits = { maxPerHour: 10, maxPending: 5 };
+const EMPTY_SYNC: ScoutSync = { state: "stale", at: null, error: null };
+
+/**
+ * The Auto Scout page's client state. It never polls and never starts a scan:
+ * the dashboard replays the worker's state and activity on connect, then
+ * streams both as the worker persists them. Controls only send commands.
+ */
+export class ScoutStore {
+  snapshot = $state<ScoutSnapshot | null>(null);
+  activity = $state<string[]>([]);
+  /** The scan whose activity is shown, so a stale stream cannot overwrite it. */
+  activityScanId = $state<string | null>(null);
+  private lastNotice: string | null = null;
+  private lastError: string | null = null;
+
+  get lifecycle(): string {
+    return this.snapshot?.lifecycle ?? "stopped";
+  }
+
+  get repo(): string | null {
+    return this.snapshot?.repo ?? null;
+  }
+
+  /**
+   * The header's origin label. A missing snapshot is not evidence that the
+   * checkout has no origin, so only a received snapshot may say so.
+   */
+  get repoLabel(): string {
+    if (this.repo !== null) return this.repo;
+    return this.snapshot === null ? "…" : "No GitHub origin";
+  }
+
+  get attached(): boolean {
+    return this.snapshot?.attached === true;
+  }
+
+  get lifecycleActive(): boolean {
+    return this.snapshot?.enabled === true || this.attached;
+  }
+
+  get issues(): ScoutIssueRow[] {
+    return this.snapshot?.issues ?? [];
+  }
+
+  /** The sidebar count: open Auto Scout issues. */
+  get count(): number {
+    return this.issues.filter((issue) => issue.state === "pending").length;
+  }
+
+  get limits(): ScoutLimits {
+    const limits = this.snapshot?.limits;
+    return limits ?? DEFAULT_LIMITS;
+  }
+
+  get sync(): ScoutSync {
+    return this.snapshot?.sync ?? EMPTY_SYNC;
+  }
+
+  get scanning(): boolean {
+    return this.snapshot?.scan !== null && this.snapshot?.scan !== undefined;
+  }
+
+  get error(): string | null {
+    return this.snapshot?.lastError ?? null;
+  }
+
+  get canStart(): boolean {
+    return connection.open && !this.attached;
+  }
+
+  get canStop(): boolean {
+    return this.attached;
+  }
+
+  start(): void {
+    connection.send({ type: "startScout" });
+  }
+
+  stop(): void {
+    connection.send({ type: "stopScout" });
+  }
+
+  saveLimits(maxPerHour: number, maxPending: number): void {
+    connection.send({ type: "setScoutLimits", maxPerHour, maxPending });
+  }
+
+  handleEvent(message: Record<string, unknown>): void {
+    if (isSnapshot(message)) {
+      const next = message as unknown as ScoutSnapshot;
+      const first = this.snapshot === null;
+      const previousScan =
+        this.snapshot?.scan?.scanId ?? this.snapshot?.newestScanId ?? null;
+      const nextScan = next.scan?.scanId ?? next.newestScanId ?? null;
+      this.snapshot = next;
+      if (nextScan !== previousScan) {
+        this.activity = [];
+        this.activityScanId = nextScan;
+      }
+      // The first snapshot of a page load is replayed state, not news.
+      if (next.lastError !== this.lastError) {
+        this.lastError = next.lastError;
+        if (next.lastError !== null && !first) {
+          notifications.push("error", next.lastError);
+        }
+      }
+      if (next.notice !== this.lastNotice) {
+        this.lastNotice = next.notice;
+        if (!first && next.notice !== null && next.notice.startsWith("Filed ")) {
+          notifications.push("success", next.notice);
+        }
+      }
+      return;
+    }
+    if (message.type === "scoutActivity" && typeof message.scanId === "string") {
+      const current = this.snapshot?.scan?.scanId ?? this.snapshot?.newestScanId ?? null;
+      if (message.scanId !== current) return;
+      this.activityScanId = message.scanId;
+      const entries = Array.isArray(message.entries) ? message.entries.filter(isEntry) : [];
+      this.activity = applyActivity(this.activity, entries, message.replay === true);
+    }
+  }
+}
+
+export const scout = new ScoutStore();

package/client/lib/skill-document.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import { renderSkillDocument, skillBody } from "./skill-document";
+
+const skill = [
+  "---",
+  "name: fixture-conventions",
+  "description: Conventions every fixture implementation agent follows.",
+  "metadata:",
+  '  devboard-managed: "true"',
+  "---",
+  "",
+  "# Fixture conventions",
+  "",
+  "- Prefer the smallest observable change.",
+  "- Run `bun test` before pushing.",
+].join("\n");
+
+describe("skillBody", () => {
+  test("drops the frontmatter and keeps the instructions", () => {
+    expect(skillBody(skill)).toBe(
+      [
+        "# Fixture conventions",
+        "",
+        "- Prefer the smallest observable change.",
+        "- Run `bun test` before pushing.",
+      ].join("\n"),
+    );
+  });
+
+  test("keeps a document without frontmatter whole", () => {
+    expect(skillBody("# Plain\n\n- One rule.")).toBe("# Plain\n\n- One rule.");
+  });
+
+  test("normalizes CRLF before reading the fence", () => {
+    expect(skillBody(skill.replaceAll("\n", "\r\n"))).toContain("# Fixture conventions");
+    expect(skillBody(skill.replaceAll("\n", "\r\n"))).not.toContain("devboard-managed");
+  });
+
+  test("treats an unclosed fence as ordinary content", () => {
+    expect(skillBody("---\nname: broken\n\n# Body")).toBe("---\nname: broken\n\n# Body");
+  });
+});
+
+describe("renderSkillDocument", () => {
+  test("renders headings, list items, and inline code as markup", () => {
+    const html = renderSkillDocument(skill);
+    expect(html).toContain("<h1>Fixture conventions</h1>");
+    expect(html).toContain("<li>Prefer the smallest observable change.</li>");
+    expect(html).toContain("<code>bun test</code>");
+    expect(html).not.toContain("devboard-managed");
+  });
+
+  test("renders fenced code without touching its text", () => {
+    const html = renderSkillDocument("```ts\nconst a = 1 < 2;\n```");
+    expect(html).toContain("language-ts");
+    expect(html).toContain("const a = 1 &lt; 2;");
+  });
+
+  test("shows raw HTML as text instead of executing it", () => {
+    const html = renderSkillDocument('<script>alert("x")</script>\n\nAfter.');
+    expect(html).not.toContain("<script>");
+    expect(html).toContain("&lt;script&gt;");
+  });
+
+  test("keeps a safe link and strips a script link to its label", () => {
+    expect(renderSkillDocument("[docs](https://example.com/x)")).toContain(
+      'href="https://example.com/x" target="_blank" rel="noreferrer noopener"',
+    );
+    const script = renderSkillDocument("[click](javascript:alert(1))");
+    expect(script).not.toContain("javascript:");
+    expect(script).toContain("click");
+  });
+
+  test("returns no markup for a frontmatter-only skill", () => {
+    expect(renderSkillDocument("---\nname: empty\n---\n")).toBe("");
+  });
+});