feat(admin): spend per trigger and per repo, and the COSTS table cycle (issue #175)

The second insights slice: the joins the graph already owned become the
cost breakdowns the fold was missing.

- attributeRunsToTriggers (read-model, beside joinRunsToTriggers): the
  per-jobId join for the cost fold -- cron via the raw repeat jobId
  grammar cronRunStats already uses, forge via the index+type agreement
  doctrine. A forge record whose pair disagrees with the current file
  (or predates the field) gets an explicit unattributed entry, never
  silence, so the fold cannot misfile it under manual.
- foldCosts gains triggerJoin -> byTrigger (typed costs, outcome split,
  failedCost, honesty buckets chained/manual/unattributed pinned to the
  tail) and byRepo (repoOfTarget, the one stripping grammar, now also
  called by forgeRepoTargets). byTrigger is null without a join: not
  computed and nothing attributed are different sentences.
- foldTriggerCosts: the per-trigger spend map keyed by the graph node
  id trigger:<index>, for the topology surfaces the next slices add.
- The COSTS view's f cycles flow/model/trigger/repo; footer hint
  renamed [f] table so width 80 still fits whole; w stays
  flow-table-only. /dispatch costs renders the two new tables; the
  trigger join is one file read, so the 10s stale-gated poll piggyback
  policy stands untouched.

Specs in the same PR: REQ-COST-ANALYTICS and DES-COST-FOLD-BY-SCAN and
DES-ADMIN-VIA-PI-EXTENSION amended; REQ-TOPOLOGY-GRAPH UNCHANGED,
checked (its join doctrine gained a second consumer, not a second
definition); DES-GRAPH-EDGE-DERIVATION UNCHANGED, checked.

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

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

Author: edgehero

admin/src/costs.mjs

@@ -235,7 +235,7 @@ function repriceRows(rows, counterfactual, pricing, { extraExcluded = 0 } = {})
  * read-model the costs view renders. Everything below is derived per call and thrown away -- nothing
  * classified here is ever written anywhere.
  */
-export function foldCosts({ records, subscriptions, pricing, nowMs, piAiPin = null, sinceMs = null }) {
+export function foldCosts({ records, subscriptions, pricing, nowMs, piAiPin = null, sinceMs = null, triggerJoin = null }) {
   const subs = Array.isArray(subscriptions) ? subscriptions : [];
   const runs = [];
   for (const record of Array.isArray(records) ? records : []) {
@@ -267,6 +267,10 @@ export function foldCosts({ records, subscriptions, pricing, nowMs, piAiPin = nu
     daily: buildDaily(runs, firstRunMs ?? fromMs, toMs),
     byFlow: buildByFlow(runs, subs, pricing),
     byModel: buildByModel(runs),
+    // null, not [], without a join: "not computed" and "nothing attributed" are different sentences,
+    // and a caller that wired no triggers must not render an empty table that looks exhaustive.
+    byTrigger: triggerJoin ? buildByTrigger(runs, triggerJoin) : null,
+    byRepo: buildByRepo(runs),
     plans: buildPlans(runs, subs, pricing, days),
     provenance: buildProvenance(runs, piAiPin),
   };
@@ -331,6 +335,130 @@ function buildByFlow(runs, subs, pricing) {
   return byFlow.sort((a, b) => b.cost.usd - a.cost.usd || a.flow.localeCompare(b.flow));
 }
 
+// The honesty buckets a run lands in when no trigger claims it, pinned to the table's tail in this
+// order however the dollars compare: a bucket named "(unattributed)" sorting above real triggers on
+// cost would read as the biggest spender when it is really the biggest unknown.
+const TRIGGER_TAIL = ["chained", "manual", "unattributed"];
+const TRIGGER_TAIL_LABELS = { chained: "(chained runs)", manual: "(manual/local)", unattributed: "(unattributed)" };
+
+/**
+ * Per-trigger rollup over the attribution the read-model passed IN (`attributeRunsToTriggers` --
+ * the index+type agreement doctrine and the raw cron jobId grammar live there and are not re-derived
+ * by this fold). Every run lands somewhere: a joined run under its trigger's graph node id
+ * (`trigger:<index>`), a forge run the join refused under "unattributed", a run with a parentJobId
+ * under "chained" (not rolled up to the ancestor trigger: walking parent chains across the retention
+ * boundary would attribute partially, and a partial rollup wearing a trigger's name is a lie), and
+ * everything else under "manual". `key` is the machine key, `label` display-only -- the byFlow
+ * lesson. The outcome split rides along because "what did failed runs cost" is a per-trigger
+ * question: a trigger whose spend is mostly failures is a different problem than an expensive one.
+ */
+function buildByTrigger(runs, triggerJoin) {
+  const byJobId = triggerJoin?.byJobId && typeof triggerJoin.byJobId === "object" ? triggerJoin.byJobId : {};
+  const groups = new Map();
+  for (const r of runs) {
+    const record = r.record;
+    const entry = typeof record.jobId === "string" ? byJobId[record.jobId] : undefined;
+    let bucket;
+    if (entry && entry.key !== "unattributed") {
+      bucket = { key: entry.key, index: entry.index ?? null, type: entry.type ?? null, label: entry.label ?? entry.key };
+    } else if (entry) {
+      bucket = { key: "unattributed", index: null, type: null, label: TRIGGER_TAIL_LABELS.unattributed };
+    } else if (typeof record.parentJobId === "string" && record.parentJobId !== "") {
+      bucket = { key: "chained", index: null, type: null, label: TRIGGER_TAIL_LABELS.chained };
+    } else {
+      bucket = { key: "manual", index: null, type: null, label: TRIGGER_TAIL_LABELS.manual };
+    }
+    if (!groups.has(bucket.key)) groups.set(bucket.key, { ...bucket, members: [] });
+    groups.get(bucket.key).members.push(r);
+  }
+  const rows = [];
+  for (const g of groups.values()) {
+    const outcomes = { completed: 0, policy: 0, failed: 0 };
+    for (const m of g.members) {
+      const o = m.record.outcome;
+      if (o === "completed" || o === "policy" || o === "failed") outcomes[o] += 1;
+    }
+    const failedMembers = g.members.filter((m) => m.record.outcome === "failed");
+    rows.push({
+      key: g.key,
+      index: g.index,
+      type: g.type,
+      label: g.label,
+      runs: g.members.length,
+      tokens: g.members.reduce((sum, m) => sum + (m.record.tokens?.total ?? 0), 0),
+      cost: combineContributions(g.members.map((m) => m.contribution)),
+      outcomes,
+      failedCost: failedMembers.length > 0 ? combineContributions(failedMembers.map((m) => m.contribution)) : null,
+    });
+  }
+  return rows.sort((a, b) => {
+    const tailA = TRIGGER_TAIL.indexOf(a.key);
+    const tailB = TRIGGER_TAIL.indexOf(b.key);
+    if (tailA !== -1 || tailB !== -1) return tailA === -1 ? -1 : tailB === -1 ? 1 : tailA - tailB;
+    return b.cost.usd - a.cost.usd || a.label.localeCompare(b.label);
+  });
+}
+
+/** A target's repo shape: the forge issue/MR tail stripped (`repo#12` -> `repo`, `proj!3` -> `proj`);
+ * targets without a numeric tail (local:<basename>) ride through whole; null stays null. The one
+ * grammar forgeRepoTargets (read-model) also strips by -- shared so the two can never disagree. */
+export function repoOfTarget(target) {
+  if (typeof target !== "string" || target === "") return null;
+  const repo = target.replace(/[#!]\d+$/, "");
+  return repo === "" ? null : repo;
+}
+
+/** Per-repo/target rollup. `key` null (with the "(no target)" display label) for records carrying no
+ * target at all; `kind` is the records' uniform kind or null when a repo saw mixed kinds. */
+function buildByRepo(runs) {
+  const groups = new Map();
+  for (const r of runs) {
+    const repo = repoOfTarget(r.record.target);
+    const mapKey = repo ?? "\u0000none";
+    if (!groups.has(mapKey)) groups.set(mapKey, { key: repo, label: repo ?? "(no target)", kinds: new Set(), members: [] });
+    const g = groups.get(mapKey);
+    if (typeof r.record.kind === "string") g.kinds.add(r.record.kind);
+    g.members.push(r);
+  }
+  const rows = [];
+  for (const g of groups.values()) {
+    rows.push({
+      key: g.key,
+      label: g.label,
+      kind: g.kinds.size === 1 ? [...g.kinds][0] : null,
+      runs: g.members.length,
+      tokens: g.members.reduce((sum, m) => sum + (m.record.tokens?.total ?? 0), 0),
+      cost: combineContributions(g.members.map((m) => m.contribution)),
+    });
+  }
+  return rows.sort((a, b) => b.cost.usd - a.cost.usd || a.label.localeCompare(b.label));
+}
+
+/**
+ * The per-trigger spend map for the topology surfaces, keyed by GRAPH NODE ID (`trigger:<index>` --
+ * graph-model mints exactly this, so a badge lands on its node with no second join vocabulary).
+ * Only real triggers appear: the chained/manual/unattributed honesty buckets have no node to badge
+ * and live in byTrigger instead.
+ */
+export function foldTriggerCosts({ records, subscriptions, pricing, triggerJoin }) {
+  const subs = Array.isArray(subscriptions) ? subscriptions : [];
+  const byJobId = triggerJoin?.byJobId && typeof triggerJoin.byJobId === "object" ? triggerJoin.byJobId : {};
+  const groups = new Map();
+  for (const record of Array.isArray(records) ? records : []) {
+    if (!record || typeof record !== "object") continue;
+    if (recordMs(record) === null) continue; // the fold's own bucketing rule: unplaceable records are dropped
+    const entry = typeof record.jobId === "string" ? byJobId[record.jobId] : undefined;
+    if (!entry || entry.key === "unattributed" || !entry.key.startsWith("trigger:")) continue;
+    if (!groups.has(entry.key)) groups.set(entry.key, []);
+    groups.get(entry.key).push(runContribution(record, subs, pricing));
+  }
+  const out = {};
+  for (const [key, contribs] of groups) {
+    out[key] = { cost: combineContributions(contribs), runs: contribs.length };
+  }
+  return out;
+}
+
 /** Per-(provider,model) rollup from the attribution rows, sorted by cost descending. A run appears in
  * a model's `runs` count once, however many of its calls landed there. */
 function buildByModel(runs) {

admin/src/dashboard.ts

@@ -30,7 +30,7 @@ import { windowEndAt } from "@edgehero/pi-dispatch/pause-windows";
 // injected seams (`fetchCosts`/`listPricedModels`/`whatIf`), never the façade, so tests stay fully
 // canned and the one worker/pricing coupling sits beside the queue and redis this module already owns.
 import * as pricing from "@edgehero/pi-dispatch/pricing";
-import { listRuns, readSettingsView, mapSchedulers, readTriggers, readPauseWindows, readStagedPackages, readSubscriptions, scanRunRecords, GRAPH_LIMITS, cronRunStats, joinRunsToTriggers, observedChainEdges, collectGraphInputs, forgeRepoTargets } from "./read-model.mjs";
+import { listRuns, readSettingsView, mapSchedulers, readTriggers, readPauseWindows, readStagedPackages, readSubscriptions, scanRunRecords, GRAPH_LIMITS, cronRunStats, joinRunsToTriggers, attributeRunsToTriggers, observedChainEdges, collectGraphInputs, forgeRepoTargets } from "./read-model.mjs";
 import { renderStatus, renderBudget, renderTriggers, renderSettingsView, renderGraph } from "./render.mjs";
 import { buildGraphModel } from "./graph-model.mjs";
 import { matchesKey } from "./keys.mjs";
@@ -62,6 +62,9 @@ const DRILL_WIDTH = 70;
 // full-directory read is the kind of quiet load a dashboard must not add, so while the view is open a
 // poll tick refreshes the fold only once the last fetch is older than this.
 const COSTS_STALE_MS = 10_000;
+// The rollup tables `f` cycles through (issue #175 added trigger and repo -- the joins the graph
+// already owned, finally answering "which trigger burns the most" and "what does repo X cost").
+const COSTS_TABLES = ["flow", "model", "trigger", "repo"];
 // GRAPH: the cursor-following row window, on the RUNS_VIEWPORT/TAIL_VIEWPORT precedent -- a fixed
 // bound with no height dependency, so an unknown terminal height changes nothing. The graph REFRESHES
 // only on entry and on `r`, never on the poll tick: fetchGraph spawns git per enumerated folder, a
@@ -138,7 +141,12 @@ export function createDashboardDeps(paths: any) {
       if (!Array.isArray(records)) return { unreachable: (records as any)?.unreachable ?? "scan failed" };
       const subsView: any = readSubscriptions({ subscriptionsPath: paths.subscriptionsPath });
       const subscriptions = Array.isArray(subsView?.subscriptions) ? subsView.subscriptions : [];
-      const fold = foldCosts({ records, subscriptions, pricing, nowMs, piAiPin: pricing.piAiVersion(), sinceMs });
+      // The trigger join behind byTrigger: one FILE read (readTriggers, the fetchSnapshot kind) plus a
+      // pure fold -- no git spawn anywhere on this path, so the 10s stale-gated poll piggyback stays
+      // exactly as cheap as it was. The graph's entry+`r`-only policy is about spawns, not reads.
+      const triggersView: any = readTriggers({ triggersPath: paths.triggersPath });
+      const triggerJoin = attributeRunsToTriggers({ records, triggers: Array.isArray(triggersView?.triggers) ? triggersView.triggers : [] });
+      const fold = foldCosts({ records, subscriptions, pricing, nowMs, piAiPin: pricing.piAiVersion(), sinceMs, triggerJoin });
       return { fold, records, subscriptions };
     },
     /**
@@ -694,7 +702,7 @@ export function makeDashboard({
           return;
         }
         if (data === "f" || data === "F") {
-          costs.table = costs.table === "flow" ? "model" : "flow";
+          costs.table = COSTS_TABLES[(COSTS_TABLES.indexOf(costs.table) + 1) % COSTS_TABLES.length];
           costsSel = 0;
           tui?.requestRender?.();
           return;
@@ -1802,10 +1810,12 @@ function costsWindowLabel(windowKey: string): string {
   return `${MONTHS[now.getUTCMonth()]} ${now.getUTCFullYear()} (mtd)`;
 }
 
-/** The active COSTS table's rows -- the array `costsSel` and ↑↓ span. */
+/** The active COSTS table's rows -- the array `costsSel` and ↑↓ span. byTrigger may be null (the
+ * seam wired no triggers): the empty array degrades the table to its stated empty line. */
 function costsTableRows(costs: any): any[] {
   const fold = costs?.data?.fold;
-  const rows = costs?.table === "model" ? fold?.byModel : fold?.byFlow;
+  const rows =
+    costs?.table === "model" ? fold?.byModel : costs?.table === "trigger" ? fold?.byTrigger : costs?.table === "repo" ? fold?.byRepo : fold?.byFlow;
   return Array.isArray(rows) ? rows : [];
 }
 
@@ -2008,6 +2018,51 @@ function costsTableLines(fold: any, table: string, costsSel: number, inner: numb
     });
     return out;
   }
+  if (table === "trigger") {
+    // The per-trigger rollup (issue #175): the FAIL column and the failed-spend suffix exist because
+    // a trigger whose spend is mostly failures is a different problem than an expensive one. The
+    // suffix rides inside the flexible COST column only when nonzero, so the row count (and with it
+    // the collapse budget) never depends on outcomes.
+    const wName = 24;
+    const wFail = 4;
+    const wCost = Math.max(8, inner - 2 - wName - wRuns - wFail - wTok - 4 * gap.length);
+    out.push(fitLine("  " + [head("TRIGGER", wName), head("RUNS", wRuns, "right"), head("FAIL", wFail, "right"), head("TOKENS", wTok, "right"), head("COST", wCost)].join(gap), inner, styler));
+    const rows = Array.isArray(fold.byTrigger) ? fold.byTrigger : [];
+    if (rows.length === 0) return [...out, fitLine(styler.fg("dim", "  (no runs in this window)"), inner, styler)];
+    rows.forEach((r: any, i: number) => {
+      const failed = r.outcomes?.failed ?? 0;
+      const costCell =
+        r.failedCost && failed > 0
+          ? styler.fmtCost(r.cost) + styler.fg("dim", ` (failed `) + styler.fmtCost(r.failedCost) + styler.fg("dim", `)`)
+          : styler.fmtCost(r.cost, wCost);
+      const cells = [
+        styler.cell(r.label ?? r.key ?? "-", wName),
+        styler.cell(String(r.runs ?? 0), wRuns, { align: "right" }),
+        styler.cell(failed > 0 ? String(failed) : "·", wFail, { align: "right" }),
+        styler.cell(fmtTokens(r.tokens ?? 0), wTok, { align: "right" }),
+        costCell,
+      ];
+      out.push(fitLine(cursor(i === costsSel) + " " + cells.join(gap), inner, styler));
+    });
+    return out;
+  }
+  if (table === "repo") {
+    const wName = 30;
+    const wCost = Math.max(8, inner - 2 - wName - wRuns - wTok - 3 * gap.length);
+    out.push(fitLine("  " + [head("REPO/TARGET", wName), head("RUNS", wRuns, "right"), head("TOKENS", wTok, "right"), head("COST", wCost)].join(gap), inner, styler));
+    const rows = Array.isArray(fold.byRepo) ? fold.byRepo : [];
+    if (rows.length === 0) return [...out, fitLine(styler.fg("dim", "  (no runs in this window)"), inner, styler)];
+    rows.forEach((r: any, i: number) => {
+      const cells = [
+        styler.cell(r.label ?? "-", wName),
+        styler.cell(String(r.runs ?? 0), wRuns, { align: "right" }),
+        styler.cell(fmtTokens(r.tokens ?? 0), wTok, { align: "right" }),
+        styler.fmtCost(r.cost, wCost),
+      ];
+      out.push(fitLine(cursor(i === costsSel) + " " + cells.join(gap), inner, styler));
+    });
+    return out;
+  }
   const wFlow = 18;
   const wCost = 14;
   const wApi = Math.max(8, inner - 2 - wFlow - wRuns - wTok - wCost - 4 * gap.length);
@@ -2107,10 +2162,11 @@ function provenanceLine(fold: any, inner: number, styler: any): string {
   return fitLine(styler.fg("dim", text), inner, styler);
 }
 
-/** The COSTS footer hints -- one line, every layer's keys named. */
+/** The COSTS footer hints -- one line, every layer's keys named. `[f] table` names the cycle rather
+ * than enumerating four table names into a footer that must fit width 80 whole. */
 function costsHints(inner: number, styler: any): string {
   const k = (key: string, label: string) => styler.fg("accent", key) + " " + styler.fg("dim", label);
-  return fitLine([k("[↑↓]", "row"), k("[f]", "flow/model"), k("[t]", "7d/30d/mtd"), k("[w]", "what-if"), k("[esc]", "back")].join(" "), inner, styler);
+  return fitLine([k("[↑↓]", "row"), k("[f]", "table"), k("[t]", "7d/30d/mtd"), k("[w]", "what-if"), k("[esc]", "back")].join(" "), inner, styler);
 }
 
 /** ms until the next UTC midnight / Monday 00:00 UTC / month-1 00:00 UTC. */

admin/src/graph-model.mjs

@@ -460,8 +460,10 @@ export function buildGraphModel({ triggers, schedulers, folderSkills, injectedSk
   return model;
 }
 
-/** The display label for a trigger's match side, mirroring render.mjs's triggerLine vocabulary. */
-function triggerMatchLabel(t) {
+/** The display label for a trigger's match side, mirroring render.mjs's triggerLine vocabulary.
+ * Exported for the read-model's cost attribution (issue #175): one vocabulary for what a trigger is
+ * called, however many tables call it. */
+export function triggerMatchLabel(t) {
   switch (t?.type) {
     case "cron":
       return `${t.id ?? "-"} ${t.pattern ?? "-"}`;

admin/src/index.ts

@@ -78,6 +78,7 @@ import {
   GRAPH_LIMITS,
   cronRunStats,
   joinRunsToTriggers,
+  attributeRunsToTriggers,
   observedChainEdges,
   collectGraphInputs,
   forgeRepoTargets,
@@ -1030,13 +1031,18 @@ function assembleCosts(paths: any, window: string, flow?: string): any {
   if (!Array.isArray(records)) return records; // { unreachable }
   const subs: any = readSubscriptions({ subscriptionsPath: paths.subscriptionsPath });
   const scoped = typeof flow === "string" && flow !== "" ? records.filter((r: any) => (r?.flow ?? null) === flow) : records;
+  // The trigger join over the SCOPED records (a flow-filtered fold attributes only what it folds),
+  // the same file-read-plus-pure-fold path the dashboard seam takes.
+  const triggersView: any = readTriggers({ triggersPath: paths.triggersPath });
+  const triggerJoin = attributeRunsToTriggers({ records: scoped, triggers: Array.isArray(triggersView?.triggers) ? triggersView.triggers : [] });
   const fold = foldCosts({
     records: scoped,
     subscriptions: Array.isArray(subs?.subscriptions) ? subs.subscriptions : [],
     pricing: PRICING,
     nowMs,
     piAiPin: piAiVersion(),
     sinceMs, // the same instant the scan cut at -- proration denominates on the requested window
+    triggerJoin,
   });
   return { fold };
 }