@homeostat/dashboard 0.1.6 → 0.1.7

package/dist/src/automation.d.ts

@@ -42,3 +42,31 @@ export interface AutomationView {
 }
 export declare function automationView(state: AutomationState, config: Config, now: Date): AutomationView;
 export declare function automationPage(v: AutomationView): string;
+/** One lamp on the console: what state the team's knowledge loop is in, at a glance. */
+export interface Lamp {
+    key: "daily" | "queue" | "sync" | "kb";
+    label: string;
+    state: "good" | "warning" | "critical" | "off";
+    value: string;
+    /** A few words under the reading. */
+    detail: string;
+    /** What this unit measures and what to do about it: the (i) text. */
+    about: string;
+    href: string;
+}
+/**
+ * The four lamps every page shows: the daily run, the review queue, developer sync and the
+ * knowledge base. `nextRun` comes from the schedule; everything else from the state branch.
+ */
+export declare function lamps(v: AutomationView, kb: {
+    stability: number;
+    accepted: number;
+    flagged: number;
+    disputed: number;
+}, now: Date, nextRun?: string): Lamp[];
+/** The first name in this checkout's git identity, for the greeting; undefined when unset. */
+export declare function firstName(kbRoot: string): string | undefined;
+/** Every lesson decided across the recorded runs, newest first. */
+export declare function decidedLessons(state: AutomationState): (RunReport["lessons"][number] & {
+    at: string;
+})[];

package/dist/src/automation.js

@@ -1,7 +1,8 @@
 import { execFileSync } from "node:child_process";
-import { REVIEW_REMINDER_DAYS, STALE_HEARTBEAT_HOURS, STATE_BRANCH, } from "@homeostat/core";
-import { columns, dataTable, esc } from "./charts.js";
+import { HEARTBEAT_PATH, REVIEW_REMINDER_DAYS, STALE_HEARTBEAT_HOURS, STATE_BRANCH, } from "@homeostat/core";
+import { columns, dataTable, esc, info } from "./charts.js";
 const REF = `refs/remotes/origin/${STATE_BRANCH}`;
+const CANDIDATES = "refs/remotes/origin/candidates/";
 function git(dir, ...args) {
     try {
         return execFileSync("git", ["-C", dir, ...args], {
@@ -32,7 +33,28 @@ export function readAutomation(kbRoot, maxRuns = 30) {
         .sort()
         .slice(-maxRuns)
         .flatMap((p) => json(kbRoot, p) ?? []);
-    const heartbeats = under("heartbeats").flatMap((p) => json(kbRoot, p) ?? []);
+    // The daily run's copy of each heartbeat is as old as the run; each developer's candidates
+    // branch has the latest one their sync pushed (sync fetches them all). Keep the newer.
+    const latest = new Map();
+    const fresher = (h) => {
+        if (!h?.member)
+            return;
+        const known = latest.get(h.member);
+        if (!known || h.at > known.at)
+            latest.set(h.member, h);
+    };
+    for (const p of under("heartbeats"))
+        fresher(json(kbRoot, p));
+    const branches = git(kbRoot, "for-each-ref", "--format=%(refname)", CANDIDATES) ?? "";
+    for (const ref of branches.split("\n").filter(Boolean)) {
+        try {
+            fresher(JSON.parse(git(kbRoot, "show", `${ref}:${HEARTBEAT_PATH}`) ?? ""));
+        }
+        catch {
+            // A candidates branch without a heartbeat: skip it.
+        }
+    }
+    const heartbeats = [...latest.values()];
     const decisions = under("decisions").flatMap((p) => json(kbRoot, p) ?? []);
     return { present: true, runs, heartbeats, decisions };
 }
@@ -41,7 +63,11 @@ export function automationView(state, config, now) {
     const health = config.team.members.map((m) => {
         const heartbeat = state.heartbeats.find((h) => h.member === m.id);
         const ageHours = heartbeat ? (now.getTime() - Date.parse(heartbeat.at)) / 3_600_000 : undefined;
-        const today = lastRun?.members.find((r) => r.member === m.id);
+        // The latest run that had lessons from this developer, not just the latest run.
+        const today = [...state.runs]
+            .reverse()
+            .map((r) => r.members.find((x) => x.member === m.id))
+            .find((x) => x !== undefined);
         return {
             member: m.id,
             role: m.role,
@@ -59,12 +85,19 @@ export function automationView(state, config, now) {
         return { ...r, member: d.member, ageDays, overdue: ageDays > REVIEW_REMINDER_DAYS };
     }))
         .sort((a, b) => b.ageDays - a.ageDays);
-    const byDay = state.runs.map((r) => ({
-        day: r.at.slice(0, 10),
-        merged: r.members.reduce((n, m) => n + m.merged, 0),
-        review: r.members.reduce((n, m) => n + m.review, 0),
-        declined: r.members.reduce((n, m) => n + m.declined, 0),
-    }));
+    // A day can have several runs (the schedule, a manual run): one bar per day.
+    const days = new Map();
+    for (const r of state.runs) {
+        const day = r.at.slice(0, 10);
+        const d = days.get(day) ?? { day, merged: 0, review: 0, declined: 0 };
+        for (const m of r.members) {
+            d.merged += m.merged;
+            d.review += m.review;
+            d.declined += m.declined;
+        }
+        days.set(day, d);
+    }
+    const byDay = [...days.values()];
     return {
         present: state.present,
         ...(lastRun ? { lastRun } : {}),
@@ -93,13 +126,13 @@ function healthRow(h) {
     const kb = !hb ? "—" : hb.behind > 0 ? `${hb.behind} behind` : "current";
     const t = h.today;
     const outcome = t
-        ? `${t.merged} merged · ${t.review} to review · ${t.declined} declined${t.mergeError ? " · merge refused" : ""}`
+        ? `${t.merged} merged, ${t.review} to review, ${t.declined} declined${t.mergeError ? ", merge refused" : ""}`
         : "—";
     return `<tr><td class="mono">${esc(h.member)}</td><td>${esc(h.role)}</td><td><span class="lamp ${lamp}" aria-hidden="true" style="display:inline-block;vertical-align:middle;margin-right:6px"></span>${esc(state)}</td><td class="num">${age(h.ageHours)}</td><td class="mono">${esc(kb)}</td><td class="num">${hb?.pending ?? "—"}</td><td class="mono">${esc(hb?.version ?? "—")}</td><td>${esc(outcome)} ${prLink(t?.dailyPr, "daily")} ${prLink(t?.reviewPr, "review")}</td></tr>`;
 }
 export function automationPage(v) {
     if (!v.present) {
-        return `<section class="panel"><h2>Automation</h2><p class="lede">No daily run on record in this clone yet. The daily run (<code>homeostat daily</code>, scheduled in the KB repo's CI) writes its decisions to the <code>${STATE_BRANCH}</code> branch, and each developer's sync fetches it. Once the first run has happened and this clone has synced, its runs, every developer's sync health and the review queue show up here.</p></section>`;
+        return `<section class="panel"><h2>Automation${info(`No daily run on record in this clone yet. The daily run (<code>homeostat daily</code>, scheduled in the KB repo's CI) writes its decisions to the <code>${STATE_BRANCH}</code> branch, and each developer's sync fetches it. Once the first run has happened and this clone has synced, its runs, every developer's sync health and the review queue show up here.`)}</h2><p class="empty">No daily run yet.</p></section>`;
     }
     const r = v.lastRun;
     const stat = (n, k) => `<div class="stat"><span class="n">${n}</span><span class="k">${k}</span></div>`;
@@ -113,21 +146,21 @@ export function automationPage(v) {
     }));
     return `<div class="grid">
 <section class="panel span-8" aria-labelledby="last"><h2 id="last">Last daily run</h2>
-${r ? `<p class="lede mono">${esc(r.at.replace("T", " ").slice(0, 16))} UTC</p>` : ""}
+${r ? `<p class="lede">${esc(r.at.replace("T", " ").slice(0, 16))} UTC</p>` : ""}
 <div class="stats" style="--cols: 4">${stat(total("merged"), "merged")}${stat(total("review"), "to review")}${stat(total("declined"), "declined")}${stat(r?.settled ?? 0, "settled by reviewers")}</div>
-${daily.length > 1 ? `<div style="margin-top:14px"><span class="label">Lessons decided per run</span>${columns(daily, { title: "Lessons decided per run", labelled: "ends", tickEvery: 7 })}${dataTable(daily, ["Run", "Lessons"])}</div>` : ""}
+${daily.length > 1 ? `<div style="margin-top:14px"><span class="label">Lessons decided per day</span>${columns(daily, { title: "Lessons decided per day", labelled: "ends", tickEvery: 7 })}${dataTable(daily, ["Day", "Lessons"])}</div>` : ""}
 ${r?.skipped?.length ? `<details style="margin-top:12px"><summary>${r.skipped.length} review thread${r.skipped.length === 1 ? "" : "s"} read with no lesson</summary><ul>${r.skipped.map((s) => `<li>${prLink(s.url, s.url.replace(/^https:\/\/[^/]+\//, ""))}: ${esc(s.reason)}</li>`).join("")}</ul></details>` : ""}</section>
 <section class="panel span-4" aria-labelledby="attention"><h2 id="attention">Needs attention</h2>
 <div class="stats" style="--cols: 2">${stat(v.queue.length, "in review")}${stat(overdue, `waiting &gt; ${REVIEW_REMINDER_DAYS} days`)}${stat(notSyncing.length, "not syncing")}${stat(r?.members.filter((m) => m.mergeError).length ?? 0, "merges refused")}</div>
-${notSyncing.length ? `<p class="lede">Not syncing: ${notSyncing.map((h) => `<span class="mono">${esc(h.member)}</span>`).join(", ")}. Their lessons reach the daily run only after a session syncs; check that the Homeostat plugin is installed for them.</p>` : ""}</section>
-<section class="panel span-12" aria-labelledby="queue"><h2 id="queue">Review queue</h2><p class="lede">Lessons the daily run could not decide on its own. Merging the review PR accepts them; closing it declines them. The next daily run records the outcome, and the developer's sync picks it up.</p>
+${notSyncing.length ? `<p>Not syncing: ${notSyncing.map((h) => `<span class="mono">${esc(h.member)}</span>`).join(", ")}${info("Their lessons reach the daily run only after one of their sessions syncs. Check that the Homeostat plugin is installed for them.")}</p>` : ""}</section>
+<section class="panel span-12" aria-labelledby="queue"><h2 id="queue">Review queue${info(`Lessons the daily run could not decide on its own. Merging the review PR accepts them; closing it declines them. The next daily run records the outcome, and the developer's sync picks it up.`)}</h2>
 ${v.queue.length
         ? `<div class="table-wrap"><table><thead><tr><th>Lesson</th><th>Developer</th><th class="num">Confidence</th><th>Why it waits</th><th class="num">Waiting</th><th>PR branch</th></tr></thead><tbody>${v.queue
             .map((q) => `<tr><td class="mono">${esc(q.id)}</td><td class="mono">${esc(q.member)}</td><td class="num">${q.confidence ?? "—"}</td><td>${esc(q.reason)}</td><td class="num">${q.overdue ? '<span class="chip disputed">' : ""}${Math.floor(q.ageDays)}d${q.overdue ? "</span>" : ""}</td><td class="mono">${esc(q.pr ?? "—")}</td></tr>`)
             .join("")}</tbody></table></div>`
         : '<p class="empty">Nothing waiting for a reviewer.</p>'}</section>
-<section class="panel span-12" aria-labelledby="health"><h2 id="health">Developer sync</h2><p class="lede">Each developer's sessions sync their clone in the background and report a heartbeat; the daily run collects them. "Not syncing" means no report for ${STALE_HEARTBEAT_HOURS} hours: normal over a weekend, worth a look after that.</p>
-<div class="table-wrap"><table><thead><tr><th>Member</th><th>Role</th><th>Sync</th><th class="num">Last report</th><th>KB clone</th><th class="num">Pending</th><th>Version</th><th>Last daily run</th></tr></thead><tbody>${v.health.map(healthRow).join("")}</tbody></table></div></section>
+<section class="panel span-12" aria-labelledby="health"><h2 id="health">Developer sync${info(`Each developer's sessions sync their clone in the background and report a heartbeat; the daily run collects them. "Not syncing" means no report for ${STALE_HEARTBEAT_HOURS} hours: normal over a weekend, worth a look after that.`)}</h2>
+<div class="table-wrap"><table><thead><tr><th>Member</th><th>Role</th><th>Sync</th><th class="num">Last report</th><th>KB clone</th><th class="num">Pending</th><th>Version</th><th>Last run with lessons</th></tr></thead><tbody>${v.health.map(healthRow).join("")}</tbody></table></div></section>
 <section class="panel span-12" aria-labelledby="runs"><h2 id="runs">Runs</h2>
 <div class="table-wrap"><table><thead><tr><th>Run</th><th class="num">Merged</th><th class="num">To review</th><th class="num">Declined</th><th class="num">Settled</th><th>Merge refused</th></tr></thead><tbody>${[
         ...v.runs,
@@ -141,3 +174,90 @@ ${v.queue.length
         .join("")}</tbody></table></div></section>
 </div>`;
 }
+const hhmm = (iso) => (iso ? iso.slice(11, 16) : "—");
+/**
+ * The four lamps every page shows: the daily run, the review queue, developer sync and the
+ * knowledge base. `nextRun` comes from the schedule; everything else from the state branch.
+ */
+export function lamps(v, kb, now, nextRun) {
+    const last = v.lastRun;
+    const ageH = last ? (now.getTime() - Date.parse(last.at)) / 3_600_000 : undefined;
+    const refused = last?.members.some((m) => m.mergeError || m.reviewError);
+    const when = (iso) => {
+        const days = Math.floor((now.getTime() - Date.parse(iso)) / 86_400_000);
+        return `${days === 0 ? "today" : days === 1 ? "yesterday" : `${days} days ago`} at ${hhmm(iso)}`;
+    };
+    const next = nextRun ? `, next ${hhmm(nextRun)}` : "";
+    const daily = {
+        key: "daily",
+        label: "Daily run",
+        href: "/automation",
+        about: "The scheduled job in the KB repo's CI. Each morning it scores every developer's new lessons and merges, declines or sends them to a reviewer.",
+        ...(!last
+            ? {
+                state: "off",
+                value: "Not run yet",
+                detail: nextRun ? `First at ${hhmm(nextRun)} UTC` : "Not scheduled",
+            }
+            : (ageH ?? 0) > 30
+                ? { state: "critical", value: "Late", detail: `Last ${when(last.at)}` }
+                : refused
+                    ? {
+                        state: "warning",
+                        value: "Needs a look",
+                        detail: "A merge or review request was refused",
+                    }
+                    : { state: "good", value: "Steady", detail: `Ran ${hhmm(last.at)}${next}` }),
+    };
+    const overdue = v.queue.filter((q) => q.overdue).length;
+    const oldest = v.queue[0];
+    const queue = {
+        key: "queue",
+        label: "Review queue",
+        href: "/automation#queue",
+        about: "Lessons the daily run could not decide on its own. Merging their review PR accepts them; closing it declines them.",
+        state: !v.present ? "off" : overdue ? "critical" : v.queue.length ? "warning" : "good",
+        value: !v.present ? "Unknown" : v.queue.length ? `${v.queue.length} waiting` : "Clear",
+        detail: !v.present || !v.queue.length
+            ? ""
+            : `Oldest ${Math.floor(oldest?.ageDays ?? 0)} days${overdue ? `, ${overdue} overdue` : ""}`,
+    };
+    const syncing = v.health.filter((h) => h.state === "ok").length;
+    const silent = v.health.filter((h) => h.state !== "ok").map((h) => h.member);
+    const sync = {
+        key: "sync",
+        label: "Developer sync",
+        href: "/automation#health",
+        about: "Each developer's sessions sync their KB clone in the background and report in. A developer silent for two days isn't sending lessons or getting the team's.",
+        state: !v.present
+            ? "off"
+            : silent.length === 0
+                ? "good"
+                : syncing === 0
+                    ? "critical"
+                    : "warning",
+        value: `${syncing} of ${v.health.length}`,
+        detail: silent.length ? `${silent.join(", ")} silent` : "",
+    };
+    const pct = Math.round(kb.stability * 100);
+    const issues = kb.flagged + kb.disputed;
+    const kbLamp = {
+        key: "kb",
+        label: "Knowledge",
+        href: "/entries",
+        about: "The share of rules an agent can rely on today: accepted, confirmed recently and not flagged.",
+        state: kb.accepted === 0 ? "off" : pct >= 80 ? "good" : pct >= 50 ? "warning" : "critical",
+        value: kb.accepted === 0 ? "Empty" : `${pct}% sound`,
+        detail: `${kb.accepted} ${kb.accepted === 1 ? "rule" : "rules"}${issues ? `, ${issues} flagged` : ""}`,
+    };
+    return [daily, queue, sync, kbLamp];
+}
+/** The first name in this checkout's git identity, for the greeting; undefined when unset. */
+export function firstName(kbRoot) {
+    const name = git(kbRoot, "config", "user.name")?.trim();
+    return name ? name.split(/\s+/)[0] : undefined;
+}
+/** Every lesson decided across the recorded runs, newest first. */
+export function decidedLessons(state) {
+    return [...state.runs].reverse().flatMap((r) => r.lessons.map((l) => ({ ...l, at: r.at })));
+}

package/dist/src/charts.d.ts

@@ -31,3 +31,22 @@ export declare function dial(value: number, opts: {
 }): string;
 /** The table view every chart offers, for screen readers and exact numbers. */
 export declare function dataTable(data: readonly Datum[], headers: [string, string]): string;
+/**
+ * An (i) that shows `html` on hover or keyboard focus. Explanations live here instead of in
+ * paragraphs. The text stays in the page for screen readers; only its box is hidden.
+ */
+export declare function info(html: string): string;
+/**
+ * A smooth area chart: one series as a curve over a soft gradient, with day labels below and the
+ * last point marked and labelled. Each point has a hover title.
+ */
+export declare function areaChart(data: readonly Datum[], opts: {
+    title: string;
+    id: string;
+}): string;
+/** Concentric rings, one per segment, each filled to its share of the largest. */
+export declare function rings(segments: readonly {
+    label: string;
+    value: number;
+    color: string;
+}[], title: string): string;

package/dist/src/charts.js

@@ -61,11 +61,15 @@ export function rows(data, opts) {
     const height = Math.max(rowH, data.length * rowH) + 4;
     const max = Math.max(1, ...data.map((d) => d.value));
     const track = width - labelW - 40;
+    // Labels are right-aligned against the bars, so a long one would run off the left edge.
+    // Monospace at the chart's 12px label size is about 7.2 units a character.
+    const fit = Math.floor((labelW - 12) / 7.2);
+    const label = (s) => (s.length > fit ? `${s.slice(0, fit - 1)}…` : s);
     const marks = data
         .map((d, i) => {
         const y = i * rowH + 4;
         const w = (d.value / max) * track;
-        return `<g class="m"><rect class="hit" x="0" y="${y - 2}" width="${width}" height="${rowH}"/><text class="t" x="${labelW - 8}" y="${y + 12}" text-anchor="end">${esc(d.label)}</text><path d="${rowPath(labelW, y + 2, w, rowH - 8)}"/><text class="v" x="${labelW + w + 6}" y="${y + 12}">${d.value}</text><title>${esc(d.title ?? `${d.label}: ${d.value}`)}</title></g>`;
+        return `<g class="m"><rect class="hit" x="0" y="${y - 2}" width="${width}" height="${rowH}"/><text class="t" x="${labelW - 8}" y="${y + 12}" text-anchor="end">${esc(label(d.label))}</text><path d="${rowPath(labelW, y + 2, w, rowH - 8)}"/><text class="v" x="${labelW + w + 6}" y="${y + 12}">${d.value}</text><title>${esc(d.title ?? `${d.label}: ${d.value}`)}</title></g>`;
     })
         .join("");
     return `<svg class="chart" viewBox="0 0 ${width} ${height}" role="img" aria-label="${esc(opts.title)}"><line class="base" x1="${labelW}" x2="${labelW}" y1="0" y2="${height}"/>${marks}</svg>`;
@@ -110,3 +114,69 @@ export function dataTable(data, headers) {
         .map((d) => `<tr><td>${esc(d.label)}</td><td class="num">${d.value}</td></tr>`)
         .join("")}</tbody></table></details>`;
 }
+/**
+ * An (i) that shows `html` on hover or keyboard focus. Explanations live here instead of in
+ * paragraphs. The text stays in the page for screen readers; only its box is hidden.
+ */
+export function info(html) {
+    return `<span class="info" tabindex="0"><span class="i" aria-hidden="true">i</span><span class="tip" role="tooltip">${html}</span></span>`;
+}
+/**
+ * A smooth area chart: one series as a curve over a soft gradient, with day labels below and the
+ * last point marked and labelled. Each point has a hover title.
+ */
+export function areaChart(data, opts) {
+    const w = 560;
+    const h = 170;
+    const pad = { top: 26, bottom: 24, left: 4, right: 14 };
+    const max = Math.max(1, ...data.map((d) => d.value));
+    const x = (i) => pad.left + (i * (w - pad.left - pad.right)) / Math.max(1, data.length - 1);
+    const y = (v) => pad.top + (1 - v / max) * (h - pad.top - pad.bottom);
+    const pts = data.map((d, i) => [x(i), y(d.value)]);
+    // Catmull-Rom to cubic Bezier: a smooth curve through every point.
+    let line = pts.length ? `M${pts[0]?.[0]},${pts[0]?.[1]}` : "";
+    for (let i = 0; i < pts.length - 1; i++) {
+        const p0 = pts[i - 1] ?? pts[i];
+        const p1 = pts[i];
+        const p2 = pts[i + 1];
+        const p3 = pts[i + 2] ?? p2;
+        if (!p0 || !p1 || !p2 || !p3)
+            continue;
+        const c1 = [p1[0] + (p2[0] - p0[0]) / 6, p1[1] + (p2[1] - p0[1]) / 6];
+        const c2 = [p2[0] - (p3[0] - p1[0]) / 6, p2[1] - (p3[1] - p1[1]) / 6];
+        line += ` C${c1[0]?.toFixed(1)},${c1[1]?.toFixed(1)} ${c2[0]?.toFixed(1)},${c2[1]?.toFixed(1)} ${p2[0].toFixed(1)},${p2[1].toFixed(1)}`;
+    }
+    const base = h - pad.bottom;
+    const area = pts.length ? `${line} L${pts.at(-1)?.[0]},${base} L${pts[0]?.[0]},${base} Z` : "";
+    const last = data.at(-1);
+    const lp = pts.at(-1);
+    const grid = [0.25, 0.5, 0.75]
+        .map((f) => `<line class="gridline" x1="0" x2="${w}" y1="${(pad.top + f * (base - pad.top)).toFixed(1)}" y2="${(pad.top + f * (base - pad.top)).toFixed(1)}"/>`)
+        .join("");
+    const labels = data
+        .map((d, i) => (i % 2 === 0 && i !== data.length - 2) || i === data.length - 1
+        ? `<text class="xl" x="${x(i).toFixed(1)}" y="${h - 4}" text-anchor="middle">${esc(d.label)}</text>`
+        : "")
+        .join("");
+    const hits = data
+        .map((d, i) => `<circle class="pt" cx="${x(i).toFixed(1)}" cy="${y(d.value).toFixed(1)}" r="9"><title>${esc(d.title ?? `${d.label}: ${d.value}`)}</title></circle>`)
+        .join("");
+    return `<svg class="area" viewBox="0 0 ${w} ${h}" role="img" aria-label="${esc(opts.title)}"><defs><linearGradient id="g-${opts.id}" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="var(--accent)" stop-opacity="0.45"/><stop offset="1" stop-color="var(--accent)" stop-opacity="0"/></linearGradient></defs>${grid}<path d="${area}" fill="url(#g-${opts.id})"/><path class="curve" d="${line}"/>${labels}${hits}${last && lp
+        ? `<circle class="last" cx="${lp[0].toFixed(1)}" cy="${lp[1].toFixed(1)}" r="5"/><g class="callout" transform="translate(${(lp[0] - 84).toFixed(1)},${Math.max(lp[1] - 17, 4).toFixed(1)})"><rect width="70" height="34" rx="6"/><text x="8" y="14" class="cl">${esc(last.label)}</text><text x="8" y="28" class="cv">${last.value}</text></g>`
+        : ""}</svg>`;
+}
+/** Concentric rings, one per segment, each filled to its share of the largest. */
+export function rings(segments, title) {
+    const size = 200;
+    const c = size / 2;
+    const max = Math.max(1, ...segments.map((s) => s.value));
+    const arcs = segments
+        .map((s, i) => {
+        const r = 86 - i * 17;
+        const len = 2 * Math.PI * r;
+        const share = s.value / max;
+        return `<circle class="ring-track" cx="${c}" cy="${c}" r="${r}"/><circle class="ring" cx="${c}" cy="${c}" r="${r}" stroke="${s.color}" stroke-dasharray="${(len * share * 0.75).toFixed(1)} ${len.toFixed(1)}" transform="rotate(-90 ${c} ${c})"><title>${esc(`${s.label}: ${s.value}`)}</title></circle>`;
+    })
+        .join("");
+    return `<svg class="rings" viewBox="0 0 ${size} ${size}" role="img" aria-label="${esc(title)}">${arcs}</svg>`;
+}

package/dist/src/server.js

@@ -3,7 +3,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { join } from "node:path";
 import { CONFIG_FILE, readEvents, readKbFiles, sectionUsage, validate, } from "@homeostat/core";
-import { automationPage, automationView, readAutomation } from "./automation.js";
+import { automationPage, automationView, decidedLessons, firstName, lamps, readAutomation, } from "./automation.js";
 import { agentLiveness, contributions, coverage, desirePaths, health, impact, } from "./metrics.js";
 import { applySection, SECTIONS } from "./settings.js";
 import { coveragePage, desirePathsPage, documentsPage, entriesPage, entryPage, eventsPage, impactPage, layout, membersPage, messagePage, overviewPage, settingsIndex, settingsPage, } from "./views.js";
@@ -89,13 +89,37 @@ export function startDashboard(opts) {
         if (!allowed(req.headers.host))
             return send(res, 421, "Misdirected request");
         const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-        const t = url.searchParams.get("theme");
+        // ?theme= picks a theme and a cookie keeps it; dark is the default.
+        const asked = url.searchParams.get("theme");
+        const kept = /(?:^|;\s*)theme=(light|dark)/.exec(req.headers.cookie ?? "")?.[1];
+        const t = asked === "light" || asked === "dark" ? asked : kept;
         const theme = t === "light" || t === "dark" ? { theme: t } : {};
-        const page = (title, body, status = 200) => send(res, status, layout({ title, path: url.pathname, kbRoot: opts.kbRoot, body, ...theme }));
+        if (asked === "light" || asked === "dark") {
+            res.setHeader("set-cookie", `theme=${asked}; Path=/; SameSite=Strict; Max-Age=31536000`);
+        }
+        let lampsNow = [];
+        const page = (title, body, status = 200) => send(res, status, layout({
+            title,
+            path: url.pathname,
+            kbRoot: opts.kbRoot,
+            body,
+            status: lampsNow,
+            ...theme,
+        }));
         const snap = snapshot();
         if (!snap) {
             return page("No knowledge base", messagePage("No knowledge base", `${CONFIG_FILE} is missing or invalid in ${opts.kbRoot}. Run homeostat validate there.`), 500);
         }
+        // The console lamps on every page: the daily run, the review queue, sync and the KB.
+        const autoState = readAutomation(opts.kbRoot);
+        const auto = automationView(autoState, snap.config, snap.now);
+        const kbHealth = health(snap);
+        lampsNow = lamps(auto, {
+            stability: kbHealth.stability,
+            accepted: kbHealth.byStatus.accepted,
+            flagged: kbHealth.flagged.length,
+            disputed: kbHealth.byStatus.disputed,
+        }, snap.now, agentLiveness(snap).find((a) => a.agent === "curator")?.nextRun);
         if (req.method === "POST") {
             // Our own pages send their origin; "null" or anything unreadable is refused, never parsed blind.
             const origin = req.headers.origin;
@@ -127,13 +151,17 @@ export function startDashboard(opts) {
         const week = new Date(snap.now.getTime() - 7 * 86_400_000).toISOString();
         switch (url.pathname) {
             case "/": {
-                const recent = snap.events.slice(-12).reverse();
-                return page("Overview", overviewPage(health(snap), agentLiveness(snap), impact(snap), recent));
+                const recent = snap.events.slice(-60).reverse();
+                return page("Overview", overviewPage(kbHealth, agentLiveness(snap), impact(snap), recent, auto, lampsNow, {
+                    ...(firstName(opts.kbRoot) ? { name: firstName(opts.kbRoot) } : {}),
+                    newThisWeek: snap.entries.filter((e) => e.frontmatter.status === "accepted" && e.frontmatter.created >= week.slice(0, 10)).length,
+                    decided: decidedLessons(autoState),
+                }));
             }
             case "/automation":
-                return page("Automation", automationPage(automationView(readAutomation(opts.kbRoot), snap.config, snap.now)));
+                return page("Automation", automationPage(auto));
             case "/entries":
-                return page("Entries", entriesPage(snap.entries, url.searchParams.get("status")));
+                return page("Entries", entriesPage(snap.entries, url.searchParams.get("status"), url.searchParams.get("q")));
             case "/members":
                 return page("Members", membersPage(contributions(snap)));
             case "/coverage":
@@ -145,7 +173,7 @@ export function startDashboard(opts) {
             case "/desire-paths":
                 return page("Desire paths", desirePathsPage(desirePaths(snap)));
             case "/events":
-                return page("Events", eventsPage(snap.events.filter((e) => e.ts >= week).reverse()));
+                return page("Events", eventsPage(snap.events.filter((e) => e.ts >= week).reverse(), url.searchParams.get("type")));
             case "/settings":
                 return page("Settings", settingsIndex());
         }

package/dist/src/views.d.ts

@@ -1,4 +1,5 @@
 import { type Config, type Entry, type Event, type Issue, type SectionUsage } from "@homeostat/core";
+import type { AutomationView, Lamp } from "./automation.ts";
 import type { AgentLiveness, Contribution, DesirePath, Health, Impact } from "./metrics.ts";
 import { type Section } from "./settings.ts";
 export declare function layout(opts: {
@@ -7,9 +8,35 @@ export declare function layout(opts: {
     kbRoot: string;
     body: string;
     theme?: "light" | "dark";
+    /** The console lamps, shown on every page. */
+    status?: Lamp[];
 }): string;
-export declare function overviewPage(h: Health, agents: AgentLiveness[], imp: Impact, recent: Event[]): string;
-export declare function entriesPage(entries: readonly Entry[], status: string | null): string;
+/** Cron as words for the common shapes (`0 6 * * *` → daily at 06:00 UTC); anything else as is. */
+export declare function schedule(expr: string): string;
+/**
+ * A state as a shape as well as a colour (never colour alone): a tick, a warning triangle, a
+ * cross, a dash. Plain strokes in currentColor, so they follow the theme.
+ */
+export declare function stateIcon(state: Lamp["state"], size?: number): string;
+/**
+ * One homeostat unit: Ashby's trough of water with a needle on a pivot. Upright is steady; the
+ * further the needle swings, the further the loop has drifted from equilibrium.
+ */
+export declare function gauge(state: Lamp["state"], width?: number, title?: string): string;
+export interface OverviewExtras {
+    name?: string;
+    /** Rules accepted in the last 7 days. */
+    newThisWeek: number;
+    decided: {
+        member: string;
+        id: string;
+        decision: string;
+        confidence?: number;
+        at: string;
+    }[];
+}
+export declare function overviewPage(h: Health, agents: AgentLiveness[], imp: Impact, _recent: Event[], v: AutomationView, _ls: readonly Lamp[], x?: OverviewExtras): string;
+export declare function entriesPage(entries: readonly Entry[], status: string | null, query?: string | null): string;
 export declare function entryPage(entry: Entry, config: Config): string;
 export declare function membersPage(rowsData: Contribution[]): string;
 export declare function coveragePage(cov: {
@@ -27,7 +54,7 @@ export declare function coveragePage(cov: {
 export declare function impactPage(imp: Impact): string;
 export declare function documentsPage(usage: readonly SectionUsage[]): string;
 export declare function desirePathsPage(paths: DesirePath[]): string;
-export declare function eventsPage(events: Event[]): string;
+export declare function eventsPage(events: Event[], type?: string | null): string;
 export declare function settingsIndex(): string;
 export declare function settingsPage(section: Section, config: Config, token: string, notice?: {
     saved?: boolean;