@intentius/behold 0.22.0 → 0.24.0

package/web/terragucci.js

@@ -0,0 +1,138 @@
+// #490: a terragucci estate painted from its reports. Pure: app.js fetches
+// /api/terragucci, then stamps cards and fills the panel tab from what these
+// functions return.
+//
+// Everything here is dated. A mark says what a run found, when that run
+// finished and how long ago that is, and links the run's report and job. No
+// mark is a fill and none says "live": a card the reports say nothing about is
+// left as it is, which is not the same as fine. A waiting wave offers only the
+// line a person runs at their shell; behold has no approve button for it.
+
+/** "4h ago", "3d ago", "just now". */
+export function ago(iso, now = new Date()) {
+  const s = Math.max(0, Math.round((now.getTime() - Date.parse(iso)) / 1000));
+  if (s < 60) return "just now";
+  const m = Math.round(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.round(m / 60);
+  if (h < 48) return `${h}h ago`;
+  return `${Math.round(h / 24)}d ago`;
+}
+
+/** The run's finish as a clock time, with the date when it is not today, in UTC so every viewer reads the same words. */
+export function clock(iso, now = new Date()) {
+  const d = new Date(iso);
+  const hhmm = `${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}`;
+  const sameDay = d.toISOString().slice(0, 10) === now.toISOString().slice(0, 10);
+  return sameDay ? `${hhmm} UTC` : `${d.toISOString().slice(0, 10)} ${hhmm} UTC`;
+}
+
+const STAGE_WORDS = { "tf-drift": "drift check", "tf-plan": "plan", "tf-apply": "apply" };
+
+/** Which run, in words: "drift check 06:04 UTC, 4h ago", "plan on PR #12 09:00 UTC, 1h ago". */
+export function runWords(run, now = new Date()) {
+  const what = run.stage === "tf-apply" && run.wave !== undefined ? `apply wave ${run.wave}` : STAGE_WORDS[run.stage] || run.stage;
+  const pr = run.pull_request ? ` on PR #${run.pull_request}` : "";
+  return `${what}${pr} ${clock(run.finished, now)}, ${ago(run.finished, now)}`;
+}
+
+/** One mark as a sentence: "drift found 06:04 UTC, 4h ago: deleted outside Terraform". */
+export function markLine(mark, now = new Date()) {
+  const lead = mark.verdict === "drift" ? "drift found" : mark.verdict === "wave" ? `wave ${mark.run.wave} waiting` : `plan${mark.run.pull_request ? ` on PR #${mark.run.pull_request}` : ""}`;
+  const attrs = mark.attributes && mark.attributes.length ? ` (${mark.attributes.join(", ")})` : "";
+  const many = mark.addresses.length > 1 ? ` · ${mark.addresses.length} instances` : "";
+  return `${lead} ${clock(mark.run.finished, now)}, ${ago(mark.run.finished, now)}: ${mark.words}${attrs}${many}`;
+}
+
+/** The corner glyph of a marked card: drift outranks a wave, a wave outranks a plan. */
+export function cornerOf(marks) {
+  if (marks.some((m) => m.verdict === "drift")) return { text: "⚠ drift", tone: "drift" };
+  if (marks.some((m) => m.verdict === "wave")) return { text: "⏸ wave", tone: "wave" };
+  return { text: "~ plan", tone: "plan" };
+}
+
+/** The address a key opens at: this server's file route, or a relative path in an export. */
+export function hrefOf(answer, key) {
+  return `${answer.files || ""}${answer.files && answer.files.includes("?") ? encodeURIComponent(key) : key}`;
+}
+
+/** The newest run any mark or root names: what the legend dates the picture by. */
+export function newestRun(answer) {
+  let best = null;
+  const see = (run) => {
+    if (run && (!best || run.finished > best.finished)) best = run;
+  };
+  for (const r of answer.roots || []) for (const k of ["plan", "drift", "apply"]) see(r[k] && r[k].run);
+  return best;
+}
+
+/** The line under the tab's title: whose reports, how old, how checked. Never "live". `title` carries the long form. */
+export function legend(answer, now = new Date()) {
+  const newest = newestRun(answer);
+  const checked = answer.validation && answer.validation.by === "schema" ? `checked against terragucci ${answer.validation.terragucci}'s schemas` : "checked structurally; install @intentius/terragucci to check against its schemas";
+  return {
+    text: `terragucci reports of ${answer.project}, not live${newest ? ` · newest run ${ago(newest.finished, now)}` : " · no runs for these roots yet"}`,
+    title: [newest ? `newest run: ${runWords(newest, now)}` : "", `${answer.reports} report${answer.reports === 1 ? "" : "s"} read from ${answer.source}`, checked].filter(Boolean).join("\n"),
+  };
+}
+
+/** A root's cell for one stage: what its newest run of that stage found, or that there is none. Short, with the clock in `title`. */
+export function stageCell(verdict, stage, now = new Date()) {
+  if (!verdict) return { text: "no report", tone: "none", title: `no ${STAGE_WORDS[stage]} report holds this root` };
+  const title = [runWords(verdict.run, now), verdict.error].filter(Boolean).join("\n");
+  const age = ago(verdict.run.finished, now);
+  if (verdict.status === "failed") return { text: `failed, ${age}`, tone: "failed", title };
+  if (stage === "tf-apply") {
+    if (verdict.approval === "waiting") return { text: `wave ${verdict.run.wave} waiting, ${age}`, tone: "wave", title };
+    return { text: `wave ${verdict.run.wave} ${verdict.applied ? "applied" : verdict.approval || "ran"}, ${age}`, tone: "ok", title };
+  }
+  if (verdict.changes === 0) return { text: `${stage === "tf-drift" ? "none" : "no changes"}, ${age}`, tone: "ok", title };
+  const noun = stage === "tf-drift" ? "drifted" : `change${verdict.changes === 1 ? "" : "s"}`;
+  const pr = verdict.run.pull_request ? ` (PR #${verdict.run.pull_request})` : "";
+  return { text: `${verdict.changes} ${noun}${pr}, ${age}`, tone: stage === "tf-drift" ? "drift" : "plan", title };
+}
+
+/** The roots table, drift first: the rows that say something come before the quiet ones. */
+export function rootRows(answer, now = new Date()) {
+  const rank = (r) => (r.drift && (r.drift.status === "failed" || r.drift.changes > 0) ? 0 : r.apply && r.apply.approval === "waiting" ? 1 : r.plan && r.plan.changes > 0 ? 2 : 3);
+  return [...(answer.roots || [])]
+    .sort((a, b) => rank(a) - rank(b) || (a.path < b.path ? -1 : 1))
+    .map((r) => ({
+      path: r.path,
+      name: r.name,
+      member: r.member,
+      drift: { ...stageCell(r.drift, "tf-drift", now), ...(r.drift ? { href: hrefOf(answer, r.drift.run.report) } : {}) },
+      plan: { ...stageCell(r.plan, "tf-plan", now), ...(r.plan ? { href: hrefOf(answer, r.plan.run.report) } : {}) },
+      apply: { ...stageCell(r.apply, "tf-apply", now), ...(r.apply ? { href: hrefOf(answer, r.apply.run.report) } : {}) },
+    }));
+}
+
+/** A waiting wave as a gate card: what it holds and destroys, how long it has waited, and the line to run. No button. */
+export function waveCards(answer, now = new Date()) {
+  return (answer.waiting || []).map((w) => ({
+    title: `wave ${w.wave} waits for an approval`,
+    facts: [
+      `since ${clock(w.since, now)}, ${ago(w.since, now)}`,
+      `${w.roots.length} root${w.roots.length === 1 ? "" : "s"}`,
+      `commit ${w.commit.slice(0, 12)}`,
+      w.set_digest ? `plan ${w.set_digest.replace(/^jcs1-sha256:/, "").slice(0, 12)}` : null,
+    ]
+      .filter(Boolean)
+      .join(" · "),
+    destroys: w.destroys,
+    command: w.command,
+    note: "An approval is a signed git record bound to this plan digest: run the line at your shell. behold does not approve.",
+    report: hrefOf(answer, w.report),
+    ...(w.job_url ? { job: w.job_url } : {}),
+  }));
+}
+
+/** terragucci's own counts, as its estate page shows them, with the page's link. */
+export function estateLine(answer) {
+  if (!answer.estate) return null;
+  const e = answer.estate;
+  return {
+    text: `terragucci's estate page: ${e.drifted} root${e.drifted === 1 ? "" : "s"} drifted · ${e.failed} failed · ${e.waiting} wave${e.waiting === 1 ? "" : "s"} waiting`,
+    href: hrefOf(answer, e.html),
+  };
+}

package/web/terragucci.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect } from "vitest";
+import { ago, clock, cornerOf, estateLine, hrefOf, legend, markLine, rootRows, runWords, stageCell, waveCards } from "./terragucci.js";
+
+const NOW = new Date("2026-10-08T10:04:12Z");
+const run = (over = {}) => ({ stage: "tf-drift", finished: "2026-10-08T06:04:12.000Z", commit: "5e6f7a8b9c0d", report: "p/r/tf-drift/report.html", ...over });
+
+describe("terragucci marks are dated, never live (#490)", () => {
+  it("says how old a run is", () => {
+    expect(ago("2026-10-08T06:04:12Z", NOW)).toBe("4h ago");
+    expect(ago("2026-10-08T10:03:50Z", NOW)).toBe("just now");
+    expect(ago("2026-10-08T09:34:12Z", NOW)).toBe("30m ago");
+    expect(ago("2026-10-04T10:04:12Z", NOW)).toBe("4d ago");
+  });
+
+  it("names the clock in UTC, with the date when it is not today", () => {
+    expect(clock("2026-10-08T06:04:12Z", NOW)).toBe("06:04 UTC");
+    expect(clock("2026-10-07T06:04:00Z", NOW)).toBe("2026-10-07 06:04 UTC");
+  });
+
+  it("reads a drift mark as terragucci would say it", () => {
+    const m = { verdict: "drift", action: "delete", words: "deleted outside Terraform", addresses: ["module.service.aws_sqs_queue.jobs"], attributes: [], run: run() };
+    expect(markLine(m, NOW)).toBe("drift found 06:04 UTC, 4h ago: deleted outside Terraform");
+  });
+
+  it("names a plan's pull request, its attributes and its instances", () => {
+    const m = { verdict: "plan", action: "replace", words: "would replace", addresses: ["x.y[0]", "x.y[1]"], attributes: ["hash_key"], run: run({ stage: "tf-plan", pull_request: "11", finished: "2026-10-08T08:00:30Z" }) };
+    expect(markLine(m, NOW)).toBe("plan on PR #11 08:00 UTC, 2h ago: would replace (hash_key) · 2 instances");
+    expect(runWords(m.run, NOW)).toBe("plan on PR #11 08:00 UTC, 2h ago");
+  });
+
+  it("puts drift ahead of a waiting wave and a wave ahead of a plan in the corner", () => {
+    const plan = { verdict: "plan" };
+    expect(cornerOf([plan, { verdict: "drift" }]).tone).toBe("drift");
+    expect(cornerOf([plan, { verdict: "wave" }]).tone).toBe("wave");
+    expect(cornerOf([plan]).tone).toBe("plan");
+  });
+
+  it("tells 'no report' from 'no changes', and a failure from both", () => {
+    expect(stageCell(undefined, "tf-plan", NOW)).toMatchObject({ text: "no report", tone: "none" });
+    expect(stageCell({ run: run(), status: "planned", changes: 0 }, "tf-drift", NOW)).toMatchObject({ text: "none, 4h ago", tone: "ok" });
+    expect(stageCell({ run: run(), status: "failed", error: "AccessDenied", changes: 0 }, "tf-drift", NOW)).toMatchObject({ text: "failed, 4h ago", tone: "failed", title: expect.stringContaining("AccessDenied") });
+    expect(stageCell({ run: run({ stage: "tf-apply", wave: 2 }), status: "planned", changes: 1, approval: "waiting" }, "tf-apply", NOW)).toMatchObject({ text: "wave 2 waiting, 4h ago", tone: "wave" });
+  });
+
+  it("says where the picture comes from and that it is not live", () => {
+    const answer = { project: "github.com/acme/shop", source: "/b", reports: 5, validation: { by: "structural" }, roots: [{ drift: { run: run() } }] };
+    const l = legend(answer, NOW);
+    expect(l.text).toBe("terragucci reports of github.com/acme/shop, not live · newest run 4h ago");
+    expect(l.title).toContain("5 reports read from /b");
+    expect(l.title).toContain("install @intentius/terragucci");
+    expect(l.text).not.toMatch(/\blive\b(?<!not live)/);
+  });
+
+  it("sorts the roots that say something first", () => {
+    const answer = {
+      files: "/api/terragucci/file?key=",
+      roots: [
+        { path: "a", drift: { run: run(), status: "planned", changes: 0 } },
+        { path: "b", drift: { run: run(), status: "planned", changes: 1 } },
+        { path: "c", apply: { run: run({ stage: "tf-apply", wave: 2 }), status: "planned", changes: 0, approval: "waiting" } },
+      ],
+    };
+    const rows = rootRows(answer, NOW);
+    expect(rows.map((r) => r.path)).toEqual(["b", "c", "a"]);
+    expect(rows[0].drift.href).toBe("/api/terragucci/file?key=p%2Fr%2Ftf-drift%2Freport.html");
+  });
+});
+
+describe("a waiting wave is a gate card with a line to copy, never a button (#490)", () => {
+  const answer = {
+    files: "/api/terragucci/file?key=",
+    waiting: [{ wave: 2, commit: "d3e4f5a6b7c8d9e0", since: "2026-10-08T09:31:00Z", roots: ["envs/staging/email", "envs/staging/orders"], set_digest: "jcs1-sha256:2e0fba16ce38925adf41", destroys: ["envs/staging/email: x (delete)"], report: "r/report.html", command: "npx terragucci approve wave-2 --plan jcs1-sha256:2e0fba16ce38925adf41", from: "estate" }],
+  };
+  it("carries what the wave holds and destroys, and how long it has waited", () => {
+    const [c] = waveCards(answer, NOW);
+    expect(c.title).toBe("wave 2 waits for an approval");
+    expect(c.facts).toBe("since 09:31 UTC, 33m ago · 2 roots · commit d3e4f5a6b7c8 · plan 2e0fba16ce38");
+    expect(c.destroys).toEqual(["envs/staging/email: x (delete)"]);
+    expect(c.command).toBe("npx terragucci approve wave-2 --plan jcs1-sha256:2e0fba16ce38925adf41");
+    expect(c).not.toHaveProperty("button");
+    expect(c.note).toContain("behold does not approve");
+  });
+
+  it("links a key through the server, or as a relative path in an export", () => {
+    expect(hrefOf({ files: "/api/terragucci/file?key=" }, "a/b.html")).toBe("/api/terragucci/file?key=a%2Fb.html");
+    expect(hrefOf({ files: "../../" }, "a/b.html")).toBe("../../a/b.html");
+  });
+
+  it("quotes terragucci's estate page, and links it", () => {
+    expect(estateLine({ files: "../../", estate: { drifted: 1, failed: 1, waiting: 1, html: "estate.html" } })).toEqual({
+      text: "terragucci's estate page: 1 root drifted · 1 failed · 1 wave waiting",
+      href: "../../estate.html",
+    });
+    expect(estateLine({})).toBeNull();
+  });
+});

package/web/why.js

@@ -0,0 +1,107 @@
+// #471: the "why" section of the inspect pane, for a member or a card in a
+// declared workspace. Pure: app.js fetches /api/workspace/why when someone
+// clicks "read why" and paints what whyView returns.
+//
+// Everything here is chant's answer (`chant workspace graph --intent <region>
+// --json`, its `why`), put into words. The decisions are chant's ranking, in
+// chant's order; behold neither re-ranks nor filters them. A proposed decision
+// links to its review in hud when behold was started with --hud, and is named
+// by its id otherwise.
+
+/** The query for a member or a node. A node wins: it names a smaller region. */
+export function whyQuery({ member = null, node = null } = {}) {
+  const q = new URLSearchParams();
+  if (node) q.set("node", node);
+  else if (member) q.set("member", member);
+  return `/api/workspace/why?${q}`;
+}
+
+/** Seconds, for "reading… 12 s" and "read in 4.1 s". */
+export function seconds(ms) {
+  if (!(ms >= 0)) return "";
+  return ms < 10_000 ? `${(ms / 1000).toFixed(1)} s` : `${Math.round(ms / 1000)} s`;
+}
+
+const RELEVANCE = {
+  carried: "carried out by the commits or runs that wrote these lines",
+  path: "constrains this path",
+  contract: "constrains it through a contract",
+  issue: "names an issue this work closed",
+  member: "constrains the whole member",
+  related: "related through supersession or an older commit",
+};
+
+const short = (sha) => String(sha || "").slice(0, 8);
+
+/**
+ * The section's content for an answer from /api/workspace/why: a headline,
+ * then decisions, runs, commits and gaps as rows of plain strings (and an
+ * href for a decision under review). `refusal` instead when chant couldn't
+ * answer.
+ */
+export function whyView(answer) {
+  if (!answer) return { refusal: { error: "no answer", remedy: "" } };
+  if (answer.refusal) return { refusal: answer.refusal, footer: footer(answer) };
+  if (answer.error) return { refusal: { error: answer.error, remedy: answer.remedy || "" } };
+  if (!answer.answered) {
+    return {
+      headline: `chant ${answer.chant || "(unknown version)"} reads the intent graph but writes no "why"; it needs chant 0.102.0 or newer in the workspace root.`,
+      decisions: [],
+      runs: [],
+      commits: [],
+      gaps: [],
+      footer: footer(answer),
+    };
+  }
+  const where = answer.path ? `${answer.path}${answer.type === "dir" ? "/" : ""}` : answer.region;
+  const current = answer.decisions.filter((d) => d.current).length;
+  let headline;
+  if (answer.decisions.length === 0) headline = `No decision covers ${where}.`;
+  else headline = `${answer.decisions.length} decision${answer.decisions.length === 1 ? "" : "s"} cover${answer.decisions.length === 1 ? "s" : ""} ${where}${current !== answer.decisions.length ? ` (${current} current)` : ""}.`;
+  if (!answer.explained && answer.decisions.length) headline += " None of them is current and accounts for it.";
+
+  const decisions = answer.decisions.map((d) => ({
+    id: d.id,
+    title: d.title || "",
+    meta: [d.state || "no state", RELEVANCE[d.relevance] || d.relevance, d.current ? null : "superseded", d.lines ? `${d.lines} line${d.lines === 1 ? "" : "s"} as its own work` : null, d.decidedBy ? `decided by ${d.decidedBy}${d.decidedOn ? ` on ${d.decidedOn}` : ""}` : null]
+      .filter(Boolean)
+      .join(" · "),
+    href: d.review || null,
+    note: d.state === "proposed" && !d.review ? "proposed; under review in hud (behold has no --hud address to link)" : null,
+  }));
+
+  const runs = answer.runs.map((r) => ({
+    id: r.id,
+    meta: [
+      r.by ? `by ${r.by}` : null,
+      r.harness ? (r.model && r.model !== "none" ? `${r.harness} · ${r.model}` : r.harness) : null,
+      r.outcome,
+      r.lines ? `${r.lines} line${r.lines === 1 ? "" : "s"}` : null,
+      r.unit ? `work ${r.unit}` : null,
+      r.commits.length ? `commit${r.commits.length === 1 ? "" : "s"} ${r.commits.map(short).join(", ")}` : null,
+      r.decisions.length ? `carried out ${r.decisions.join(", ")}` : null,
+    ]
+      .filter(Boolean)
+      .join(" · "),
+    when: r.startedAt || "",
+  }));
+
+  const commits = answer.commits.map((c) => ({
+    sha: short(c.sha),
+    subject: c.subject || "",
+    meta: [c.author, c.date ? c.date.slice(0, 10) : null, c.pullRequest ? `#${c.pullRequest}` : null, c.run ? `run ${c.run}` : null].filter(Boolean).join(" · "),
+  }));
+  const more = answer.commitsTotal > answer.commits.length ? answer.commitsTotal - answer.commits.length : 0;
+  const gaps = answer.gaps.map((g) => g.message || g.code);
+  if (answer.uncommittedLines) gaps.unshift(`${answer.uncommittedLines} line${answer.uncommittedLines === 1 ? " isn't" : "s aren't"} committed yet.`);
+  return { headline, decisions, runs, commits, more, gaps, footer: footer(answer) };
+}
+
+function footer(answer) {
+  const parts = [];
+  if (typeof answer.ms === "number") parts.push(`read in ${seconds(answer.ms)}`);
+  if (answer.chant) parts.push(`chant ${answer.chant}`);
+  const region = answer.region ? String(answer.region).replace(/^region:/, "") : null;
+  if (region) parts.push(`chant workspace graph --intent ${region}`);
+  return parts.join(" · ");
+}

package/web/why.test.js

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { seconds, whyQuery, whyView } from "./why.js";
+
+const answer = (over = {}) => ({
+  workspace: true,
+  member: "delivery",
+  ms: 4120,
+  chant: "0.102.0",
+  region: "region:delivery/src/app.ts",
+  path: "delivery/src/app.ts",
+  type: "file",
+  answered: true,
+  explained: true,
+  decisions: [
+    { id: "fix-002", title: "Where kept records wait", state: "proposed", relevance: "member", current: true, closed: false, lines: 0, decidedBy: null, decidedOn: null, review: "http://hud.test/decisions#fix-002" },
+    { id: "fix-001", title: "How the app is deployed", state: "decided", relevance: "member", current: true, closed: false, lines: 0, decidedBy: "lex00", decidedOn: "2026-09-24", review: null },
+  ],
+  runs: [{ id: "conformance-run", lines: 4, commits: ["6b3865dd9936437b58ca8bf84db0ec5264d85f7b"], unit: null, by: "conformance", harness: "conformance", model: "none", outcome: "done", startedAt: "2026-01-01T00:00:00Z", endedAt: null, decisions: [] }],
+  commits: [{ sha: "6b3865dd9936437b58ca8bf84db0ec5264d85f7b", subject: "the reader conformance workspace", date: "2026-10-07T23:45:37-06:00", author: "chant", pullRequest: null, run: "conformance-run" }],
+  commitsTotal: 1,
+  uncommittedLines: 0,
+  gaps: [],
+  ...over,
+});
+
+describe("whyQuery (#471)", () => {
+  it("asks about the node when there is one, the member otherwise", () => {
+    expect(whyQuery({ member: "delivery", node: "delivery/appService" })).toBe("/api/workspace/why?node=delivery%2FappService");
+    expect(whyQuery({ member: "delivery" })).toBe("/api/workspace/why?member=delivery");
+  });
+});
+
+describe("whyView (#471)", () => {
+  it("names the decisions in chant's order, linking a proposed one to hud", () => {
+    const v = whyView(answer());
+    expect(v.headline).toBe("2 decisions cover delivery/src/app.ts.");
+    expect(v.decisions.map((d) => d.id)).toEqual(["fix-002", "fix-001"]);
+    expect(v.decisions[0].href).toBe("http://hud.test/decisions#fix-002");
+    expect(v.decisions[1].href).toBeNull();
+    expect(v.decisions[1].meta).toContain("decided by lex00 on 2026-09-24");
+    expect(v.runs[0].meta).toContain("commit 6b3865dd");
+    expect(v.commits[0]).toMatchObject({ sha: "6b3865dd", subject: "the reader conformance workspace" });
+    expect(v.footer).toBe("read in 4.1 s · chant 0.102.0 · chant workspace graph --intent delivery/src/app.ts");
+  });
+
+  it("without hud, a proposed decision is its id and says where it is reviewed", () => {
+    const d = answer().decisions[0];
+    const v = whyView(answer({ decisions: [{ ...d, review: null }] }));
+    expect(v.decisions[0].href).toBeNull();
+    expect(v.decisions[0].note).toContain("under review in hud");
+  });
+
+  it("says when nothing covers it, and what chant couldn't account for", () => {
+    const v = whyView(answer({ decisions: [], explained: false, uncommittedLines: 2, gaps: [{ code: "intent-why-no-decision", message: "no current decision governs it" }] }));
+    expect(v.headline).toBe("No decision covers delivery/src/app.ts.");
+    expect(v.gaps).toEqual(["2 lines aren't committed yet.", "no current decision governs it"]);
+  });
+
+  it("an old chant, a refusal and a missing workspace each say so in words", () => {
+    expect(whyView(answer({ answered: false, chant: "0.95.0" })).headline).toContain("needs chant 0.102.0");
+    expect(whyView({ workspace: true, refusal: { error: "nope", remedy: "do this" }, region: "delivery/x", ms: 600 }).refusal.error).toBe("nope");
+    expect(whyView({ workspace: false, error: "not a workspace" }).refusal.error).toBe("not a workspace");
+  });
+
+  it("counts seconds the way the reading line does", () => {
+    expect(seconds(950)).toBe("0.9 s");
+    expect(seconds(29_400)).toBe("29 s");
+  });
+});