feat(admin): schedule and spend on the graph, and the HTML honesty carry-through (issue #175)

The third insights slice: the facts the graph computed and never said.

- Trigger nodes gain cost (the typed spend foldTriggerCosts maps onto
  the node id) -- a node FACT beside runs/lastOutcome, no new edge kind,
  no new flag, the closed vocabularies pinned unchanged. The assemblers
  wire it with one extra file read and two pure folds over the scan
  they already paid for; the GRAPH view's entry-plus-r-only refresh
  policy is untouched and the real-poll pin proves it.
- Cron rows finally render next/overdue: next as a countdown against
  the model's own generatedAt (never a live clock; a stale model shows
  its stale countdown honestly), overdue in the error color. Both in
  the TUI and in /dispatch graph text.
- Spend renders only through fmtCost/styler.fmtCost, so a plan-covered
  trigger reads plan:<id> on the graph too, never $0.00.
- graph.html: normalizeModel carries meta.chainRefusals,
  meta.injectedUnreachable and observed-edge lastEndedAt; the legend
  states the two counters the text and TUI always stated; an observed
  wire's label says how fresh it is beside its count. Node cost is
  deliberately NOT allowlisted there: the page cannot use the from
  clause, and a hand-copied money formatter is a parity liability the
  insights artifact avoids by taking the real formatter.

Specs in the same PR: REQ-TOPOLOGY-GRAPH gains (h);
REQ-GRAPH-HTML-EXPORT amended (honesty counters, edge recency);
DES-GRAPH-EDGE-DERIVATION and DES-ADMIN-VIA-PI-EXTENSION amended;
REQ-COST-ANALYTICS UNCHANGED, checked; DES-COST-FOLD-BY-SCAN
UNCHANGED, checked. docs/graph.md updated.

Suite green in the CI posture: 2197 tests, 0 skipped, live Valkey.

Signed-off-by: Rob Boerman <robboerman@live.nl>

Author: edgehero

admin/src/dashboard.ts

@@ -36,7 +36,7 @@ import { buildGraphModel } from "./graph-model.mjs";
 import { matchesKey } from "./keys.mjs";
 import { box, meter, clip, fmtUsd, makeLineInput } from "./panel.mjs";
 import { makeStyler, frame, RULE } from "./style.mjs";
-import { COSTS_WINDOWS, costsSinceMs, foldCosts, whatIfFlow } from "./costs.mjs";
+import { COSTS_WINDOWS, costsSinceMs, foldCosts, foldTriggerCosts, whatIfFlow } from "./costs.mjs";
 
 const KEY_HINTS = "[p]ause  [r]esume  [q]uit";
 // Fetch the read-model's full window (listRuns clamps at 50) but render a cursor-following viewport of
@@ -161,6 +161,10 @@ export function createDashboardDeps(paths: any) {
       const triggerList: any[] = Array.isArray(triggersView?.triggers) ? triggersView.triggers : [];
       const records: any = scanRunRecords({ logsDir: paths.logsDir, sinceMs: nowMs - GRAPH_LIMITS.windowDays * 24 * 60 * 60 * 1000, nowMs });
       const recs: any[] = Array.isArray(records) ? records : [];
+      // Spend badges (issue #175): one more FILE read (subscriptions) and two pure folds over the
+      // scan this seam already paid for -- no new spawn, so the entry+`r`-only policy is untouched.
+      const subsView: any = readSubscriptions({ subscriptionsPath: paths.subscriptionsPath });
+      const triggerJoin = attributeRunsToTriggers({ records: recs, triggers: triggerList });
       return buildGraphModel({
         triggers: triggersView,
         schedulers: Array.isArray(schedulers) ? schedulers : [],
@@ -171,6 +175,7 @@ export function createDashboardDeps(paths: any) {
         forgeRepos: forgeRepoTargets({ records: recs }),
         caps: { chainDepthMax: paths.chainDepthMax, chainMaxPerJob: paths.chainMaxPerJob, windowDays: GRAPH_LIMITS.windowDays },
         nowMs,
+        triggerCosts: foldTriggerCosts({ records: recs, subscriptions: Array.isArray(subsView?.subscriptions) ? subsView.subscriptions : [], pricing, triggerJoin }),
       });
     },
     /** The priced-model catalog for the what-if `/` filter -- the façade stays behind this seam. */
@@ -1623,7 +1628,9 @@ function graphRows(model: any, folded: any): any[] {
     if (isFolded) continue;
     for (const id of group.triggerIds ?? []) {
       const node: any = nodeById.get(id);
-      if (node) rows.push({ kind: "gtrigger", node, flags: flagsByNode.get(id) ?? [] });
+      // generatedAt rides on the row so graphRowLine can phrase `next` as a countdown without a
+      // clock of its own -- render() stays a pure read of component state.
+      if (node) rows.push({ kind: "gtrigger", node, flags: flagsByNode.get(id) ?? [], generatedAt: model.meta?.generatedAt ?? null });
     }
     for (const id of group.skillIds ?? []) {
       const node: any = nodeById.get(id);
@@ -1661,8 +1668,17 @@ function graphRowLine(row: any, cursor: boolean, inner: number, styler: any): st
     const stats = t.runs > 0 ? `runs ${t.runs}${t.lastOutcome ? ` · last ${t.lastOutcome}` : ""}` : "no runs in window";
     const statColor = t.lastOutcome === "completed" ? "success" : t.lastOutcome ? "warning" : "dim";
     const badges = graphBadges(row.flags, styler);
+    // The schedule fact the model always computed and no surface rendered (issue #175): overdue in
+    // the error color -- the money backstop's own signal -- else the next fire as a countdown against
+    // the model's generatedAt (never a live clock; a stale model shows its stale countdown honestly).
+    const parts: string[] = [styler.fg(statColor, stats)];
+    const schedule = triggerScheduleText(t, row.generatedAt);
+    if (schedule) parts.push(styler.fg(schedule.startsWith("overdue") ? "error" : "dim", schedule));
+    // Window spend, typed: fmtCost is the only money renderer, so a plan-covered trigger reads
+    // plan:<id> here too, never $0.00.
+    if (t.cost) parts.push(styler.fmtCost(t.cost));
     const left = pre + kind + styler.stripAnsi(t.label ?? "") + " " + styler.fg("dim", G.arrowRight) + " " + (t.flow ?? "(no flow)") + (t.replicas ? styler.fg("warning", ` x${t.replicas}`) : "") + badges;
-    const right = styler.fg(statColor, stats);
+    const right = parts.join(styler.fg("dim", " · "));
     return joinEnds(left, right, inner, styler);
   }
   if (row.kind === "gskill") {
@@ -1695,6 +1711,19 @@ function graphRowLine(row: any, cursor: boolean, inner: number, styler: any): st
   return fitLine(pre, inner, styler);
 }
 
+/** A cron trigger's schedule phrase: "overdue 2h" from the model's own overdueMs, else "next 4h"
+ * counted from the model's generatedAt (the scheduler's `next` is ms in production and ISO in older
+ * fixtures -- both parse). Empty for non-cron triggers and for anything unparseable: a schedule badge
+ * that guesses is worse than none. */
+function triggerScheduleText(t: any, generatedAt: any): string {
+  if (Number.isFinite(t?.overdueMs) && t.overdueMs > 0) return `overdue ${humanizeMs(t.overdueMs) || "<1m"}`;
+  const nextMs = typeof t?.next === "number" ? t.next : typeof t?.next === "string" ? Date.parse(t.next) : NaN;
+  if (!Number.isFinite(nextMs) || !Number.isFinite(generatedAt)) return "";
+  const inMs = nextMs - generatedAt;
+  if (inMs <= 0) return ""; // due-but-not-overdue noise; the overdue branch owns the alarm
+  return `next ${humanizeMs(inMs) || "<1m"}`;
+}
+
 /** The flag badges every graph row shares, colored by severity; the vocabulary is graph-model's. */
 function graphBadges(flags: string[], styler: any): string {
   const parts: string[] = [];

admin/src/graph-html.mjs

@@ -181,6 +181,17 @@ function normalizeModel(model) {
       skills: m.meta?.truncated?.skills === true,
       edges: m.meta?.truncated?.edges === true,
     },
+    // The two honesty counters the text and TUI renderers always carried and this allowlist
+    // dropped (issue #175): three surfaces of one model must not disagree about what was refused
+    // or unreadable. Sorted and clipped like every other array on this page.
+    chainRefusals: (m.meta?.chainRefusals && typeof m.meta.chainRefusals === "object" ? Object.entries(m.meta.chainRefusals) : [])
+      .flatMap(([scope, count]) => (typeof scope === "string" && intOr(count, 0) > 0 ? [{ scope: clip(scope, 80), count: intOr(count, 0) }] : []))
+      .sort((a, b) => cmpStr(a.scope, b.scope)),
+    injectedUnreachable: (Array.isArray(m.meta?.injectedUnreachable) ? m.meta.injectedUnreachable : [])
+      .filter((d) => typeof d === "string")
+      .map((d) => clip(d, 120))
+      .sort()
+      .slice(0, 8),
   };
 
   const folders = [];
@@ -248,6 +259,9 @@ function normalizeModel(model) {
       strong: e.strong === true,
       eligible: e.eligible === true,
       label: typeof e.label === "string" ? e.label : null,
+      // Observed-edge recency (issue #175), the node-side lastEndedAt sanitizer: "chained 3 times,
+      // last 2d ago" and "chained 3 times, months back" are different topologies to a reader.
+      lastEndedAt: typeof e.lastEndedAt === "string" || Number.isFinite(e.lastEndedAt) ? e.lastEndedAt : null,
     });
   }
   edges.sort((a, b) => cmpStr(a.kind, b.kind) || cmpStr(a.from, b.from) || cmpStr(a.to, b.to) || cmpStr(a.label ?? "", b.label ?? "") || (a.count ?? -1) - (b.count ?? -1) || (a.strong ? 1 : 0) - (b.strong ? 1 : 0));
@@ -833,14 +847,17 @@ function wireStyle(w) {
   return { stroke: CHIP_FILL.cron, width: 2, dash: "4,3" }; // cron-rearm: dashed in the trigger's own hue
 }
 
-function wireSvg(w) {
+function wireSvg(w, nowMs) {
   const s = wireStyle(w);
   const parts = [`<g class="gwire" id="${w.id}">`];
   parts.push(`<path d="${w.d}" fill="none" stroke="${s.stroke}" stroke-width="${fmt(s.width)}"${s.dash !== null ? ` stroke-dasharray="${s.dash}"` : ""}/>`);
   let label = null;
   let fill = PAGE_DIM;
   if (w.kind === "observed" && w.edge.count !== null) {
-    label = `(${w.edge.count}×)`;
+    // Recency beside the count when the fold recorded it: relTime against the injected instant,
+    // so the byte-determinism guarantee holds -- same model + same now, same label.
+    const ago = relTime(nowMs, w.edge.lastEndedAt);
+    label = ago !== null ? `(${w.edge.count}× · ${ago})` : `(${w.edge.count}×)`;
     fill = WIRE_OBSERVED;
   } else if (w.kind === "potential") {
     label = "mention";
@@ -913,6 +930,10 @@ function legendHtml(norm) {
   if (norm.meta.truncated.skills) honesty.push("skill enumeration truncated or partly unread");
   if (norm.meta.truncated.edges) honesty.push("observed edges truncated (cap reached)");
   if (norm.meta.droppedObservedEdges > 0) honesty.push(`${norm.meta.droppedObservedEdges} observed edges dropped (no unique folder)`);
+  // The counters the text and TUI surfaces already state (issue #175): the page joins them.
+  const refused = norm.meta.chainRefusals.reduce((a, r) => a + r.count, 0);
+  if (refused > 0) honesty.push(`${refused} chain requests refused (caps or gate)`);
+  if (norm.meta.injectedUnreachable.length > 0) honesty.push(`injected skills dir unreadable: ${norm.meta.injectedUnreachable.join(", ")}`);
   for (const line of honesty) rows.push(`<div class="honesty">${escapeHtml(line)}</div>`);
   return `<div id="legend">${rows.join("")}</div>`;
 }
@@ -1198,7 +1219,7 @@ export function buildGraphHtml(model, { now, fullPaths } = {}) {
   const svgBody = [
     layout.groups.map((g) => groupSvg(g, fullPaths)).join(""),
     layout.skillGroups.map(skillGroupSvg).join(""),
-    layout.wires.map(wireSvg).join(""),
+    layout.wires.map((w) => wireSvg(w, nowMs)).join(""),
     nodeParts.join(""),
   ].join("");
   const vb = layout.viewBox;

admin/src/graph-model.mjs

@@ -160,14 +160,18 @@ export const GRAPH_FLAGS = Object.freeze([
  * Total function: absent or malformed inputs degrade to an empty-but-well-formed model, never a
  * throw (the read-model's viewer doctrine, one layer up).
  */
-export function buildGraphModel({ triggers, schedulers, folderSkills, injectedSkills, foldersTruncated, forgeRepos, cronStats, runJoin, chainEdges, caps, nowMs } = {}) {
+export function buildGraphModel({ triggers, schedulers, folderSkills, injectedSkills, foldersTruncated, forgeRepos, cronStats, runJoin, chainEdges, caps, nowMs, triggerCosts } = {}) {
   const triggerList = Array.isArray(triggers?.triggers) ? triggers.triggers : [];
   const schedulerList = Array.isArray(schedulers) ? schedulers : [];
   const folders = folderSkills && typeof folderSkills === "object" ? folderSkills : {};
   const injected = injectedSkills && typeof injectedSkills === "object" ? injectedSkills : {};
   const statsById = cronStats?.byId && typeof cronStats.byId === "object" ? cronStats.byId : {};
   const statsByIndex = runJoin?.byIndex && typeof runJoin.byIndex === "object" ? runJoin.byIndex : {};
   const observed = Array.isArray(chainEdges?.edges) ? chainEdges.edges : [];
+  // The per-trigger spend map (costs.mjs foldTriggerCosts), keyed by this module's own node ids.
+  // Spend is a node FACT like runs/lastOutcome -- no new edge kind, no new flag: the closed
+  // vocabularies stay closed, and a fold that wires no costs simply grows no badges.
+  const spendByNode = triggerCosts && typeof triggerCosts === "object" ? triggerCosts : {};
 
   const model = {
     folders: [],
@@ -345,6 +349,9 @@ export function buildGraphModel({ triggers, schedulers, folderSkills, injectedSk
       lastEndedAt: stats?.lastEndedAt ?? null,
       next: sched?.next ?? null,
       overdueMs: sched?.overdueMs ?? null,
+      // The window's typed spend for this trigger, or null when none was wired/attributed. Carried
+      // whole (usd/class/floor) so every renderer keeps the fmtCost labeling discipline.
+      cost: spendByNode[id]?.cost ?? null,
     };
     model.nodes.push(node);
     if (group) group.triggerIds.push(id);

admin/src/index.ts

@@ -98,7 +98,7 @@ import { applyDeploymentPointer, pointerPath, readPointer, takePointerNotice } f
 // The only fs use in this module: the skew notice reads one package.json through the wizard's own reader.
 // Everything else fs-shaped goes through read-model.mjs by design.
 import * as nodeFs from "node:fs";
-import { COSTS_WINDOWS, costsSinceMs, foldCosts, whatIfFlow } from "./costs.mjs";
+import { COSTS_WINDOWS, costsSinceMs, foldCosts, foldTriggerCosts, whatIfFlow } from "./costs.mjs";
 // The REAL pricing façade. costs.mjs may not hold a module-scope worker/pricing import by contract (the
 // fold is pure; tests inject a canned fake) -- index.ts is where the fs-adjacent assembly lives, so the
 // injection happens here.
@@ -1063,6 +1063,9 @@ async function assembleGraph(paths: any): Promise<any> {
   const schedulers: any = await readSchedulers({ url: paths.valkeyUrl });
   const records: any = scanRunRecords({ logsDir: paths.logsDir, sinceMs: nowMs - GRAPH_LIMITS.windowDays * 24 * 60 * 60 * 1000, nowMs });
   const recs: any[] = Array.isArray(records) ? records : [];
+  // Spend badges (issue #175): the dashboard seam's twin -- one subscriptions read, two pure folds.
+  const subsView: any = readSubscriptions({ subscriptionsPath: paths.subscriptionsPath });
+  const triggerJoin = attributeRunsToTriggers({ records: recs, triggers: triggerList });
   return buildGraphModel({
     triggers,
     schedulers: Array.isArray(schedulers) ? schedulers : [],
@@ -1073,6 +1076,7 @@ async function assembleGraph(paths: any): Promise<any> {
     forgeRepos: forgeRepoTargets({ records: recs }),
     caps: { chainDepthMax: paths.chainDepthMax, chainMaxPerJob: paths.chainMaxPerJob, windowDays: GRAPH_LIMITS.windowDays },
     nowMs,
+    triggerCosts: foldTriggerCosts({ records: recs, subscriptions: Array.isArray(subsView?.subscriptions) ? subsView.subscriptions : [], pricing: PRICING, triggerJoin }),
   });
 }
 

admin/src/render.mjs

@@ -427,7 +427,7 @@ export function renderGraph(model) {
     out.push("", groupHeading(group));
     for (const id of group.triggerIds ?? []) {
       const t = nodeById.get(id);
-      if (t) out.push(`  ${graphTriggerLine(t, flagsByNode.get(id) ?? [])}`);
+      if (t) out.push(`  ${graphTriggerLine(t, flagsByNode.get(id) ?? [], m.meta?.generatedAt ?? null)}`);
     }
     for (const id of group.skillIds ?? []) {
       const s = nodeById.get(id);
@@ -477,14 +477,34 @@ function groupHeading(group) {
   return `folder ${group.path ?? group.label}${head}${state}`;
 }
 
-function graphTriggerLine(t, flags) {
-  const stats = t.runs > 0 ? `runs ${t.runs}${t.lastOutcome ? `, last ${t.lastOutcome}` : ""}` : "no runs in window";
+function graphTriggerLine(t, flags, generatedAt = null) {
+  // The schedule and spend facts join the stats parens (issue #175): overdue from the model's own
+  // overdueMs, next as a countdown against generatedAt (never a clock -- this renderer is pure),
+  // spend through fmtCost so a plan-covered trigger reads plan:<id> in text too.
+  const bits = [t.runs > 0 ? `runs ${t.runs}${t.lastOutcome ? `, last ${t.lastOutcome}` : ""}` : "no runs in window"];
+  if (Number.isFinite(t.overdueMs) && t.overdueMs > 0) bits.push(`overdue ${relDuration(t.overdueMs)}`);
+  else {
+    const nextMs = typeof t.next === "number" ? t.next : typeof t.next === "string" ? Date.parse(t.next) : NaN;
+    if (Number.isFinite(nextMs) && Number.isFinite(generatedAt) && nextMs > generatedAt) bits.push(`next ${relDuration(nextMs - generatedAt)}`);
+  }
+  if (t.cost) bits.push(`spend ${fmtCost(t.cost)}`);
   const badges = [];
   if (flags.includes("no-skill")) badges.push("[no-skill: flow absent at HEAD]");
   if (flags.includes("charset-invalid")) badges.push("[invalid flow name: can never materialise]");
   if (flags.includes("pr-spend-loop-risk")) badges.push("[spend-loop risk: fires on opened/synchronize]");
   const replicas = t.replicas ? ` x${t.replicas}` : "";
-  return `${t.onType} ${t.label} -> ${t.flow ?? "(no flow)"}${replicas}  (${stats})${badges.length ? ` ${badges.join(" ")}` : ""}`;
+  return `${t.onType} ${t.label} -> ${t.flow ?? "(no flow)"}${replicas}  (${bits.join(", ")})${badges.length ? ` ${badges.join(" ")}` : ""}`;
+}
+
+/** A coarse duration for the graph's schedule facts: minutes under an hour, else hours, else days. */
+function relDuration(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "<1m";
+  const min = Math.floor(ms / 60000);
+  if (min < 1) return "<1m";
+  if (min < 60) return `${min}m`;
+  const h = Math.floor(min / 60);
+  if (h < 48) return `${h}h`;
+  return `${Math.round(h / 24)}d`;
 }
 
 function graphSkillLine(s, flags) {

admin/test/dashboard.test.mjs

@@ -1964,6 +1964,32 @@ async function openGraph(deps, width = 80) {
   return comp;
 }
 
+test("GRAPH trigger rows say next/overdue and typed spend when the model carries them (issue #175)", async () => {
+  const model = CANNED_GRAPH_MODEL();
+  const cron = model.nodes.find((n) => n.id === "trigger:0");
+  cron.next = (model.meta.generatedAt ?? 0) + 4 * 3600_000;
+  cron.cost = { usd: 0, class: "plan", floor: false, planId: "kimi" };
+  const comp = await openGraph(graphDeps({ fetchGraph: async () => model }));
+  const out = stripAnsi(comp.render(100).join("\n"));
+  await comp.dispose();
+  assert.match(out, /next 4h/, "the countdown against the model's own generatedAt, never a live clock");
+  assert.match(out, /plan:kimi/, "spend through styler.fmtCost: a plan-covered trigger never reads $0.00");
+  assert.doesNotMatch(out, /\$0\.00/);
+
+  const overdueModel = CANNED_GRAPH_MODEL();
+  const c2 = overdueModel.nodes.find((n) => n.id === "trigger:0");
+  c2.overdueMs = 2 * 3600_000;
+  const comp2 = await openGraph(graphDeps({ fetchGraph: async () => overdueModel }));
+  const out2 = stripAnsi(comp2.render(100).join("\n"));
+  await comp2.dispose();
+  assert.match(out2, /overdue 2h/, "the money backstop's own signal, finally on the row");
+
+  const bare = await openGraph(graphDeps());
+  const out3 = stripAnsi(bare.render(100).join("\n"));
+  await bare.dispose();
+  assert.doesNotMatch(out3, /next |overdue /, "no scheduler match: no claim, not a guess");
+});
+
 test("'g' opens GRAPH, the footer advertises it unclipped at 80, and Esc pops one layer", async () => {
   const deps = graphDeps();
   const comp = makeDashboard({ paths: {}, done() {}, tui: fakeTui(), intervalMs: 100000, deps });

admin/test/graph-html.test.mjs

@@ -327,14 +327,24 @@ test("orphan dash, potential-vs-observed labels, the caps digits, and honesty co
   // mention): those two chips plus the one legend swatch carry the disabled treatment, and the
   // exact count is the negative claim -- no non-orphan chip may wear it.
   assert.equal((out.match(/stroke-dasharray="8,3"/g) ?? []).length, 3, "two orphan chips and the one legend swatch, nothing else");
-  assert.equal((out.match(/\(\d+×\)/g) ?? []).length, 1, "one observed edge, one count label; a potential wire NEVER carries a count");
+  // The observed label carries the count and, when the fold recorded one, the recency (issue #175):
+  // "chained 2 times, 2d ago" and "chained 2 times, months back" are different topologies to a reader.
+  assert.equal((out.match(/\(\d+×( · \d+[smhd] ago)?\)/g) ?? []).length, 1, "one observed edge, one count label; a potential wire NEVER carries a count");
+  assert.match(out, /\(\d+× · \d+[smhd] ago\)/, "the canned observed edge has a lastEndedAt, so its label says how fresh it is");
   assert.ok(out.includes(">mention</text>"), "a potential wire is labelled mention instead");
   assert.ok(out.includes("chains: depth ≤ 1 · ≤ 2 per job · same folder only · window 30d"), "the caps line renders the model's exact digits");
   assert.ok(out.includes("2 runs unattributed"), "honesty counters render when set");
 
   const dropped = buildGraphModel(CANNED());
   dropped.meta.droppedObservedEdges = 4;
   assert.ok(buildGraphHtml(dropped, { now: NOW }).includes("4 observed edges dropped"), "dropped-edge counter renders when set");
+
+  // The two counters the text and TUI surfaces always stated and this page dropped (issue #175):
+  // three surfaces of one model must not disagree about what was refused or unreadable.
+  assert.ok(out.includes("1 chain requests refused (caps or gate)"), "the canned refusals reach the legend");
+  const unreadable = buildGraphModel(CANNED());
+  unreadable.meta.injectedUnreachable = ["/inj"];
+  assert.ok(buildGraphHtml(unreadable, { now: NOW }).includes("injected skills dir unreadable: /inj"), "the unreadable-dir counter renders when set");
 });
 
 // ---- 10. refresh features ----