@edgehero/pi-dispatch-admin 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -7689,12 +7689,18 @@ function defaultSandboxDir(env = process.env) {
 function defaultLogsDir() {
   return `${process.env.TMPDIR ?? process.env.TEMP ?? "/tmp"}/pi-dispatch/logs`.replace(/\\/g, "/");
 }
+function defaultGraphDir(env = process.env) {
+  return `${env.TMPDIR ?? env.TEMP ?? "/tmp"}/pi-dispatch/graph`.replace(/\\/g, "/");
+}
 function defaultSettingsFile() {
   return `${process.env.TMPDIR ?? process.env.TEMP ?? "/tmp"}/pi-dispatch/settings.json`.replace(/\\/g, "/");
 }
+var CHAIN_DEPTH_MAX_DEFAULT, CHAIN_MAX_PER_JOB_DEFAULT;
 var init_config2 = __esm({
   "../worker/src/config.mjs"() {
     init_forges();
+    CHAIN_DEPTH_MAX_DEFAULT = 1;
+    CHAIN_MAX_PER_JOB_DEFAULT = 2;
   }
 });
 
@@ -8262,7 +8268,7 @@ function normalizeWindow(w, index, path) {
   return norm;
 }
 function zonedParts(tz, ms) {
-  const fmt = new Intl.DateTimeFormat("en-US", {
+  const fmt2 = new Intl.DateTimeFormat("en-US", {
     timeZone: tz,
     hour12: false,
     year: "numeric",
@@ -8273,7 +8279,7 @@ function zonedParts(tz, ms) {
     weekday: "short"
   });
   const p = {};
-  for (const part of fmt.formatToParts(new Date(ms))) p[part.type] = part.value;
+  for (const part of fmt2.formatToParts(new Date(ms))) p[part.type] = part.value;
   let hh = Number(p.hour);
   if (hh === 24) hh = 0;
   return { y: Number(p.year), mo: Number(p.month), d: Number(p.day), hh, mi: Number(p.minute), dow: WEEKDAY_INDEX[p.weekday] };
@@ -8594,9 +8600,9 @@ var init_flow_gate = __esm({
 
 // ../worker/src/git-dirty.mjs
 import { execFileSync } from "node:child_process";
-function gitDirty(folder, { exec: exec3 = execFileSync } = {}) {
+function gitDirty(folder, { exec: exec4 = execFileSync } = {}) {
   try {
-    const out = exec3("git", ["-C", folder, "status", "--porcelain"], { encoding: "utf8" });
+    const out = exec4("git", ["-C", folder, "status", "--porcelain"], { encoding: "utf8" });
     return out.trim().length > 0;
   } catch {
     return null;
@@ -8748,6 +8754,493 @@ var init_packages = __esm({
   }
 });
 
+// ../worker/src/materialize.mjs
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+function isWindowsDeviceName(segment) {
+  const stem = segment.split(".")[0].toLowerCase();
+  return WINDOWS_DEVICE_NAMES.has(stem);
+}
+function classifyPiPath(path) {
+  if (path === APPEND_SYSTEM) return { outRel: "pi/APPEND_SYSTEM.md", skill: null };
+  if (!path.startsWith(SKILLS_PREFIX)) return null;
+  const segments = path.slice(SKILLS_PREFIX.length).split("/");
+  if (segments.length < 2 || segments.length > 1 + PI_LIMITS.maxTailSegments) return null;
+  const [name, ...tail] = segments;
+  if (!SKILL_NAME_RE.test(name)) return null;
+  for (const seg of tail) {
+    if (!PI_SEGMENT_RE.test(seg)) return null;
+    if (isWindowsDeviceName(seg)) return null;
+  }
+  const outRel = ["pi", "skills", name, ...tail].join("/");
+  if (outRel.length > PI_LIMITS.maxOutRelChars) return null;
+  return { outRel, skill: name };
+}
+function selectEntries(lsTreeZ) {
+  const entries = [];
+  let skipped = 0;
+  for (const record of lsTreeZ.split("\0")) {
+    if (!record) continue;
+    const tab = record.indexOf("	");
+    if (tab === -1) continue;
+    const [mode, type, oid, sizeField] = record.slice(0, tab).split(/\s+/);
+    const path = record.slice(tab + 1);
+    if (mode !== "100644" || type !== "blob") {
+      skipped++;
+      continue;
+    }
+    const size = Number(sizeField);
+    if (!Number.isSafeInteger(size) || size < 0) {
+      throw new Error(`git ls-tree: unreadable object size (is -l still in the argv?) for ${type} ${mode} ${oid}`);
+    }
+    const classified = classifyPiPath(path);
+    if (!classified) {
+      skipped++;
+      continue;
+    }
+    entries.push({ oid, path, size, outRel: classified.outRel, skill: classified.skill });
+  }
+  return { entries, skipped };
+}
+function keepOnlyDeclaredSkills(entries) {
+  const declared = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.skill !== null && e.outRel.endsWith(`/${SKILL_FILE}`)) declared.add(e.skill);
+  }
+  const kept = entries.filter((e) => e.skill === null || declared.has(e.skill));
+  return { kept, skipped: entries.length - kept.length };
+}
+var exec2, PI_DIR, APPEND_SYSTEM, SKILLS_PREFIX, SKILL_FILE, PI_LIMITS, LS_TREE_MAX_BYTES, PI_SEGMENT_RE, WINDOWS_DEVICE_NAMES;
+var init_materialize = __esm({
+  "../worker/src/materialize.mjs"() {
+    init_flow_gate();
+    exec2 = promisify3(execFile3);
+    PI_DIR = ".pi";
+    APPEND_SYSTEM = `${PI_DIR}/APPEND_SYSTEM.md`;
+    SKILLS_PREFIX = `${PI_DIR}/skills/`;
+    SKILL_FILE = "SKILL.md";
+    PI_LIMITS = Object.freeze({
+      maxFiles: 256,
+      // ~50 typical skills; also bounds cat-file spawns per job
+      maxFilesPerSkill: 64,
+      // SKILL.md + references/ + scripts/ + assets/ runs to a handful
+      maxFileBytes: 1 << 20,
+      // 1 MiB: ~250k words of markdown. Larger is a dataset, not a skill.
+      maxTotalBytes: 8 << 20,
+      // 8 MiB: trivial beside the clone, and it bounds host disk under retention
+      maxTailSegments: 4,
+      // references/x.md is 2, scripts/lib/util.sh is 3
+      maxOutRelChars: 200
+      // Windows MAX_PATH is 260 and jobDir is an OS temp path (~40-70)
+    });
+    LS_TREE_MAX_BYTES = 1 << 20;
+    PI_SEGMENT_RE = /^[a-z0-9](?:[a-z0-9_.-]{0,62}[a-z0-9])?$/i;
+    WINDOWS_DEVICE_NAMES = /* @__PURE__ */ new Set([
+      "con",
+      "prn",
+      "aux",
+      "nul",
+      "com1",
+      "com2",
+      "com3",
+      "com4",
+      "com5",
+      "com6",
+      "com7",
+      "com8",
+      "com9",
+      "lpt1",
+      "lpt2",
+      "lpt3",
+      "lpt4",
+      "lpt5",
+      "lpt6",
+      "lpt7",
+      "lpt8",
+      "lpt9"
+    ]);
+  }
+});
+
+// src/graph-model.mjs
+function parseSkillMeta(text) {
+  const empty = { name: null, description: null };
+  if (typeof text !== "string") return empty;
+  const normalized = text.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+  const block = FRONTMATTER_BLOCK_RE.exec(normalized);
+  if (!block) return empty;
+  return {
+    name: frontmatterValue(block[1], "name"),
+    description: frontmatterValue(block[1], "description")
+  };
+}
+function frontmatterValue(block, key) {
+  const m = new RegExp(`^${key}:[ \\t]*(.*)$`, "m").exec(block);
+  if (!m) return null;
+  let value = m[1].trim();
+  if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+  if (value === "") return null;
+  return value.length > META_VALUE_MAX_CHARS ? `${value.slice(0, META_VALUE_MAX_CHARS)}\u2026` : value;
+}
+function findSiblingMentions(text, siblingNames) {
+  if (typeof text !== "string" || !Array.isArray(siblingNames)) return [];
+  const mentions = [];
+  for (const name of siblingNames) {
+    if (typeof name !== "string" || name === "") continue;
+    const re = new RegExp(`(?<![a-z0-9_-])${escapeRegExp(name)}(?![a-z0-9_-])`, "g");
+    let found = false;
+    let strong = false;
+    let match;
+    let occurrences = 0;
+    while ((match = re.exec(text)) !== null && occurrences++ < 32) {
+      found = true;
+      const windowStart = Math.max(0, match.index - CHAIN_VOCAB_RADIUS);
+      const windowEnd = Math.min(text.length, match.index + name.length + CHAIN_VOCAB_RADIUS);
+      if (CHAIN_VOCAB_RE.test(text.slice(windowStart, windowEnd))) {
+        strong = true;
+        break;
+      }
+    }
+    if (found) mentions.push({ name, strong });
+  }
+  return mentions;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findLoopHints(text) {
+  if (typeof text !== "string") return [];
+  const normalized = text.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+  const body = normalized.replace(FRONTMATTER_BLOCK_RE, "");
+  const hints = [];
+  const seen = /* @__PURE__ */ new Set();
+  let match;
+  LOOP_HINT_RE.lastIndex = 0;
+  while ((match = LOOP_HINT_RE.exec(body)) !== null && hints.length < LOOP_HINT_MAX) {
+    const hint = match[0].trim();
+    const key = hint.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    hints.push({ hint });
+  }
+  return hints;
+}
+function buildGraphModel({ triggers, schedulers, folderSkills, injectedSkills, foldersTruncated, forgeRepos, cronStats, runJoin, chainEdges, caps, nowMs } = {}) {
+  const triggerList2 = 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 : [];
+  const model = {
+    folders: [],
+    nodes: [],
+    edges: [],
+    flags: [],
+    caps: {
+      chainDepthMax: Number.isInteger(caps?.chainDepthMax) ? caps.chainDepthMax : null,
+      chainMaxPerJob: Number.isInteger(caps?.chainMaxPerJob) ? caps.chainMaxPerJob : null,
+      sameFolderOnly: true,
+      windowDays: Number.isInteger(caps?.windowDays) ? caps.windowDays : null
+    },
+    meta: {
+      generatedAt: Number.isFinite(nowMs) ? nowMs : null,
+      triggersMissing: triggers?.missing === true,
+      triggersInvalid: typeof triggers?.invalid === "string" ? triggers.invalid : null,
+      unattributedRuns: Number.isInteger(runJoin?.unattributed) ? runJoin.unattributed : 0,
+      chainRefusals: chainEdges?.refusals && typeof chainEdges.refusals === "object" ? chainEdges.refusals : {},
+      truncated: {
+        // collectGraphInputs' cap flag rides its spread into this input (review finding: this was
+        // hardcoded false, so the cap-reached banner could never fire on any surface).
+        folders: foldersTruncated === true,
+        skills: Object.values(folders).some((f) => f?.truncated === true),
+        edges: chainEdges?.truncated === true
+      },
+      droppedObservedEdges: 0,
+      // Injected dirs whose readdir failed (review finding): the OQ-022 badge is the one fact the
+      // injected enumeration exists for, and an unreadable dir must not make it silently vanish.
+      injectedUnreachable: Object.entries(injected).filter(([, r]) => typeof r?.unreachable === "string").map(([dir]) => dir).sort()
+    }
+  };
+  const folderByPath = /* @__PURE__ */ new Map();
+  for (const [path, result] of Object.entries(folders)) {
+    const group = {
+      key: `folder:${path}`,
+      path,
+      label: basenameOf(path),
+      kind: "local",
+      head: typeof result?.head === "string" ? result.head : null,
+      unreachable: typeof result?.unreachable === "string" ? result.unreachable : null,
+      triggerIds: [],
+      skillIds: []
+    };
+    folderByPath.set(path, group);
+    model.folders.push(group);
+  }
+  const forgeGroups = /* @__PURE__ */ new Map();
+  const forgeGroup = (forge) => {
+    const name = typeof forge === "string" && forge !== "" ? forge : "forge";
+    let group = forgeGroups.get(name);
+    if (!group) {
+      const repos = Array.isArray(forgeRepos?.[name]) ? forgeRepos[name] : [];
+      group = { key: `forge:${name}`, path: null, label: name, kind: "forge", head: null, unreachable: "remote-repo", repos, triggerIds: [], skillIds: [] };
+      forgeGroups.set(name, group);
+      model.folders.push(group);
+    }
+    return group;
+  };
+  const skillNode = /* @__PURE__ */ new Map();
+  const addSkill = (group, skill) => {
+    const id = `skill:${group.key}:${skill.name}`;
+    const node = {
+      id,
+      kind: "skill",
+      name: skill.name,
+      folderKey: group.key,
+      isSub: skill.isSub === true,
+      group: skill.isSub === true ? skill.group : null,
+      aiTrigger: skill.aiTrigger === true,
+      meta: skill.meta ?? null,
+      // The prose-loop hints read from the SKILL.md body (findLoopHints): everything a loop does
+      // happens INSIDE this one node's job, which is why consumers group the marker inside the
+      // skill rather than drawing an edge anywhere.
+      loops: Array.isArray(skill.loops) ? skill.loops.filter((l) => typeof l?.hint === "string") : [],
+      unread: skill.unread === true,
+      isFlow: false,
+      // set true when a config edge lands on it
+      mentionedBy: 0
+    };
+    skillNode.set(`${group.key} ${skill.name}`, node);
+    model.nodes.push(node);
+    group.skillIds.push(id);
+    if (node.unread) model.flags.push({ nodeId: id, flag: "unread", detail: "SKILL.md unreadable at enumeration; gate read as closed" });
+    return node;
+  };
+  for (const [path, result] of Object.entries(folders)) {
+    const group = folderByPath.get(path);
+    for (const skill of Array.isArray(result?.skills) ? result.skills : []) {
+      if (typeof skill?.name === "string" && skill.name !== "") addSkill(group, skill);
+    }
+  }
+  for (const [dir, result] of Object.entries(injected)) {
+    for (const skill of Array.isArray(result?.skills) ? result.skills : []) {
+      if (typeof skill?.name !== "string" || skill.name === "") continue;
+      const id = `injected:${dir}:${skill.name}`;
+      model.nodes.push({ id, kind: "injected", name: skill.name, dir, aiTrigger: skill.aiTrigger === true });
+      if (skill.aiTrigger === true) {
+        model.flags.push({ nodeId: id, flag: "injected-ai-trigger", detail: "ai-trigger: allow on an injected skill is a silent no-op (OQ-022)" });
+      }
+    }
+  }
+  const missingNode = (group, name) => {
+    const key = `${group.key} ${name}`;
+    let node = skillNode.get(key);
+    if (node) return node;
+    node = { id: `skill:${group.key}:${name}`, kind: "skill-missing", name, folderKey: group.key, isSub: false, group: null, aiTrigger: false, meta: null, unread: false, isFlow: false, mentionedBy: 0 };
+    skillNode.set(key, node);
+    model.nodes.push(node);
+    group.skillIds.push(node.id);
+    return node;
+  };
+  for (const t of triggerList2) {
+    if (!t || typeof t !== "object" || !Number.isInteger(t.index)) continue;
+    const id = `trigger:${t.index}`;
+    const isCron = t.type === "cron";
+    let group = null;
+    if (isCron) {
+      if (typeof t.folder === "string" && t.folder !== "") {
+        group = folderByPath.get(t.folder) ?? null;
+        if (!group) {
+          group = { key: `folder:${t.folder}`, path: t.folder, label: basenameOf(t.folder), kind: "local", head: null, unreachable: "not-enumerated", triggerIds: [], skillIds: [] };
+          folderByPath.set(t.folder, group);
+          model.folders.push(group);
+        }
+      } else {
+        group = folderByPath.get("") ?? null;
+        if (!group) {
+          group = { key: "folder:(none)", path: null, label: "(no folder)", kind: "local", head: null, unreachable: "no-folder", triggerIds: [], skillIds: [] };
+          folderByPath.set("", group);
+          model.folders.push(group);
+        }
+      }
+    } else {
+      group = forgeGroup(t.forge);
+    }
+    const stats = isCron ? typeof t.id === "string" ? statsById[t.id] : void 0 : statsByIndex[t.index];
+    const sched = isCron ? matchScheduler(schedulerList, t) : null;
+    const node = {
+      id,
+      kind: "trigger",
+      index: t.index,
+      onType: t.type,
+      forge: isCron ? null : t.forge ?? null,
+      cronId: isCron ? t.id ?? null : null,
+      pattern: isCron ? t.pattern ?? null : null,
+      label: triggerMatchLabel(t),
+      flow: t.flow ?? null,
+      replicas: t.replicas ?? null,
+      folderKey: group?.key ?? null,
+      runs: Number.isInteger(stats?.runs) ? stats.runs : 0,
+      lastOutcome: stats?.lastOutcome ?? null,
+      lastEndedAt: stats?.lastEndedAt ?? null,
+      next: sched?.next ?? null,
+      overdueMs: sched?.overdueMs ?? null
+    };
+    model.nodes.push(node);
+    if (group) group.triggerIds.push(id);
+    if (t.type === "pull_request" && Array.isArray(t.action) && t.action.some((a) => a === "opened" || a === "synchronize")) {
+      model.flags.push({ nodeId: id, flag: "pr-spend-loop-risk", detail: "fires on opened/synchronize; a flow that pushes can loop with another bot (OQ-020)" });
+    }
+    if (isCron) model.edges.push({ from: id, to: id, kind: "cron-rearm", label: t.pattern ?? null });
+    if (typeof t.flow === "string" && t.flow !== "") {
+      if (!SKILL_NAME_RE.test(t.flow)) {
+        const target = group ? missingNode(group, clipName(t.flow)) : null;
+        if (target) model.edges.push({ from: id, to: target.id, kind: "config" });
+        model.flags.push({ nodeId: id, flag: "charset-invalid", detail: `run.flow ${JSON.stringify(clipName(t.flow))} fails the skill charset and can never materialise` });
+        continue;
+      }
+      if (isCron && group && group.unreachable === null) {
+        const existing = skillNode.get(`${group.key} ${t.flow}`);
+        if (existing && existing.kind === "skill" && !existing.isSub) {
+          existing.isFlow = true;
+          model.edges.push({ from: id, to: existing.id, kind: "config" });
+        } else {
+          const target = missingNode(group, t.flow);
+          model.edges.push({ from: id, to: target.id, kind: "config" });
+          model.flags.push({ nodeId: id, flag: "no-skill", detail: `.pi/skills/${t.flow}/SKILL.md absent at HEAD` });
+        }
+      } else if (group) {
+        const target = missingNode(group, t.flow);
+        if (target.kind === "skill-missing") target.kind = "skill-unverified";
+        target.isFlow = true;
+        model.edges.push({ from: id, to: target.id, kind: "config" });
+      }
+    }
+  }
+  const localGroups = model.folders.filter((f) => f.kind === "local");
+  for (const edge of observed) {
+    if (typeof edge?.parentFlow !== "string" || typeof edge?.childFlow !== "string") continue;
+    const base = typeof edge.target === "string" && edge.target.startsWith("local:") ? edge.target.slice("local:".length) : null;
+    const matches = base === null ? [] : localGroups.filter((f) => f.label === base);
+    if (matches.length !== 1) {
+      model.meta.droppedObservedEdges++;
+      continue;
+    }
+    const group = matches[0];
+    if (group.unreachable !== null) {
+      model.meta.droppedObservedEdges++;
+      continue;
+    }
+    const from = missingNode(group, edge.parentFlow);
+    const to = missingNode(group, edge.childFlow);
+    model.edges.push({ from: from.id, to: to.id, kind: "observed", count: Number.isInteger(edge.count) ? edge.count : 0, lastEndedAt: edge.lastEndedAt ?? null });
+  }
+  for (const [path, result] of Object.entries(folders)) {
+    const group = folderByPath.get(path);
+    for (const skill of Array.isArray(result?.skills) ? result.skills : []) {
+      if (skill?.isSub === true) continue;
+      const from = skillNode.get(`${group.key} ${skill?.name}`);
+      if (!from) continue;
+      for (const mention of Array.isArray(skill?.mentions) ? skill.mentions : []) {
+        const to = skillNode.get(`${group.key} ${mention?.name}`);
+        if (!to || to.isSub) continue;
+        to.mentionedBy++;
+        model.edges.push({
+          from: from.id,
+          to: to.id,
+          kind: "potential",
+          strong: mention.strong === true,
+          // Eligibility is the exact static half: without ai-trigger: allow on the TARGET, the
+          // outbox gate refuses this edge every time, so a mention alone renders "can never fire".
+          eligible: to.aiTrigger === true
+        });
+      }
+    }
+  }
+  for (const [path] of Object.entries(folders)) {
+    const group = folderByPath.get(path);
+    if (group.unreachable !== null) continue;
+    for (const id of group.skillIds) {
+      const node = model.nodes.find((n) => n.id === id);
+      if (!node || node.kind !== "skill" || node.isSub || node.unread) continue;
+      if (node.isFlow) continue;
+      if (node.aiTrigger) {
+        model.flags.push({ nodeId: id, flag: "ai-reachable-no-trigger", detail: "no trigger names it, but ai-trigger: allow keeps it chain/dispatch_run-reachable" });
+      } else if (node.mentionedBy === 0) {
+        model.flags.push({ nodeId: id, flag: "orphan", detail: "no trigger, no ai-trigger, no mention: dead by every path the system has" });
+      }
+    }
+  }
+  return model;
+}
+function triggerMatchLabel(t) {
+  switch (t?.type) {
+    case "cron":
+      return `${t.id ?? "-"} ${t.pattern ?? "-"}`;
+    case "label":
+      return selectorLabel(t);
+    case "comment":
+      return `"${t.phrase ?? "-"}"`;
+    case "pull_request":
+      return `action[${(Array.isArray(t.action) ? t.action : []).join(",")}]`;
+    default:
+      return "(unknown)";
+  }
+}
+function selectorLabel(t) {
+  const parts = [];
+  if (Array.isArray(t.any) && t.any.length) parts.push(`any[${t.any.join(",")}]`);
+  if (Array.isArray(t.all) && t.all.length) parts.push(`all[${t.all.join(",")}]`);
+  if (Array.isArray(t.none) && t.none.length) parts.push(`none[${t.none.join(",")}]`);
+  return parts.join(" ") || "(no selector)";
+}
+function matchScheduler(schedulers, t) {
+  if (typeof t?.id === "string") {
+    const byId = schedulers.find((s) => s?.key === t.id || s?.name === t.id);
+    if (byId) return byId;
+  }
+  return typeof t?.pattern === "string" ? schedulers.find((s) => s?.pattern === t.pattern) ?? null : null;
+}
+function basenameOf(path) {
+  const trimmed = String(path).replace(/[\\/]+$/, "");
+  const at = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  return at === -1 ? trimmed : trimmed.slice(at + 1);
+}
+function clipName(name) {
+  const s = String(name);
+  return s.length > 64 ? `${s.slice(0, 64)}\u2026` : s;
+}
+var FRONTMATTER_BLOCK_RE, META_VALUE_MAX_CHARS, CHAIN_VOCAB_RE, CHAIN_VOCAB_RADIUS, LOOP_HINT_RE, LOOP_HINT_MAX, GRAPH_EDGE_KINDS, GRAPH_FLAGS;
+var init_graph_model = __esm({
+  "src/graph-model.mjs"() {
+    init_flow_gate();
+    FRONTMATTER_BLOCK_RE = /^---\n([\s\S]*?)\n---(?:\n|$)/;
+    META_VALUE_MAX_CHARS = 120;
+    CHAIN_VOCAB_RE = /outbox|request-|"flow"|\bchain\b|follow-up/i;
+    CHAIN_VOCAB_RADIUS = 200;
+    LOOP_HINT_RE = /\b(?:until|repeat(?:ing)?|iterate(?:s|d)?|loop(?:s|ing)?|while|for each|keep \w+ing|try again)\b[^.\n]{0,60}/gi;
+    LOOP_HINT_MAX = 3;
+    GRAPH_EDGE_KINDS = Object.freeze(["config", "observed", "potential", "cron-rearm"]);
+    GRAPH_FLAGS = Object.freeze([
+      "no-skill",
+      // config edge target absent at HEAD in an ENUMERATED folder (readFlowGate's precise token)
+      "charset-invalid",
+      // run.flow fails SKILL_NAME_RE: can never materialise, a distinct defect from no-skill
+      "orphan",
+      // no trigger, no ai-trigger, no incoming mention: dead by every path the system has
+      "ai-reachable-no-trigger",
+      // no trigger but ai-trigger: allow -- deliberately chain/dispatch_run-reachable
+      "injected-ai-trigger",
+      // an injected skill carrying ai-trigger: allow is a silent no-op (OQ-022)
+      "unread",
+      // SKILL.md unreadable/oversized at enumeration: facts unknown, gate read as closed
+      "pr-spend-loop-risk"
+      // pull_request on opened/synchronize: the OQ-020 cross-actor spend-loop signature
+    ]);
+  }
+});
+
 // src/read-model.mjs
 import * as nodeFs2 from "node:fs";
 import { join as join2, delimiter, sep } from "node:path";
@@ -8789,7 +9282,18 @@ function resolvePaths(env = process.env) {
     dispatchRunPerHour: parseNonNegInt(env.PI_DISPATCH_RUN_PER_HOUR, 3),
     // The per-scheduler stall threshold, mirrored from the worker's PI_SCHEDULER_STALL_MAX (default 2) so the
     // cron drill-in can show `stalls n/threshold`. Read directly from env for the same reason as above.
-    schedulerStallMax: parseNonNegInt(env.PI_SCHEDULER_STALL_MAX, 2)
+    schedulerStallMax: parseNonNegInt(env.PI_SCHEDULER_STALL_MAX, 2),
+    // The chain caps the graph states (issue #54), on the schedulerStallMax pattern: env read directly
+    // (never loadConfig), DEFAULTS imported from the worker so there is no second literal to drift --
+    // a graph printing "depth <= 1" while the worker enforces 2 would be the exact dishonesty the
+    // GRAPH view exists to remove.
+    chainDepthMax: parseNonNegInt(env.PI_CHAIN_DEPTH_MAX, CHAIN_DEPTH_MAX_DEFAULT),
+    chainMaxPerJob: parseNonNegInt(env.PI_CHAIN_MAX_PER_JOB, CHAIN_MAX_PER_JOB_DEFAULT),
+    // Where the graph HTML artifact lands (issue #54): the worker's own temp-dir default, imported
+    // like defaultLogsDir/defaultSandboxDir above, so the admin and any future worker consumer agree
+    // on the path without loadConfig. Deliberately NOT logsDir -- that directory's filename shape is
+    // contract (INT-RUN-HISTORY-FILE-CONTRACT).
+    graphDir: env.PI_GRAPH_DIR || defaultGraphDir(env)
   };
 }
 function parseNonNegInt(raw, fallback) {
@@ -8826,9 +9330,9 @@ async function setQueuePaused({ url, paused, makeQueueFn = makeQueue, parseConne
     });
   }
 }
-function revParseHead(folder, { exec: exec3 = execFileSync2 } = {}) {
+function revParseHead(folder, { exec: exec4 = execFileSync2 } = {}) {
   try {
-    const out = exec3("git", ["-C", folder, "rev-parse", "HEAD"], { encoding: "utf8" });
+    const out = exec4("git", ["-C", folder, "rev-parse", "HEAD"], { encoding: "utf8" });
     const sha = out.trim();
     return sha.length > 0 ? sha : null;
   } catch {
@@ -9143,11 +9647,11 @@ function readTriggers({ triggersPath, fs = nodeFs2 }) {
     return { invalid: 'triggers file must have a "triggers" array' };
   }
   const triggers = [];
-  for (const entry of entries) {
+  entries.forEach((entry, index) => {
     const display = normalizeTriggerForDisplay(entry);
-    if (display) triggers.push(display);
-  }
-  return { triggers };
+    if (display) triggers.push({ ...display, index });
+  });
+  return { triggers, count: entries.length };
 }
 function normalizeTriggerForDisplay(entry) {
   if (entry === null || typeof entry !== "object") return null;
@@ -9229,6 +9733,225 @@ function readStagedPackages({ globalPiDir, fs = nodeFs2, readManifest: readManif
 function nameAtVersion(pkg) {
   return typeof pkg.version === "string" && pkg.version !== "" ? `${pkg.name}@${pkg.version}` : pkg.name;
 }
+function cronRunStats({ records, schedulerIds } = {}) {
+  const byId = {};
+  if (!Array.isArray(records) || !Array.isArray(schedulerIds)) return { byId };
+  for (const id of schedulerIds) {
+    if (typeof id !== "string" || id === "") continue;
+    const re = new RegExp(`^repeat:${escapeRegExp2(id)}:(\\d+)$`);
+    let runs = 0;
+    let lastMillis = -1;
+    let last = null;
+    for (const record of records) {
+      const m = typeof record?.jobId === "string" ? re.exec(record.jobId) : null;
+      if (!m) continue;
+      runs++;
+      const millis = Number(m[1]);
+      if (millis > lastMillis) {
+        lastMillis = millis;
+        last = record;
+      }
+    }
+    byId[id] = {
+      runs,
+      lastOutcome: last?.outcome ?? null,
+      lastEndedAt: last ? last.endedAt ?? last.startedAt ?? null : null
+    };
+  }
+  return { byId };
+}
+function joinRunsToTriggers({ records, triggerCount, triggerTypes } = {}) {
+  const byIndex = {};
+  let unattributed = 0;
+  if (!Array.isArray(records)) return { byIndex, unattributed };
+  const count = Number.isInteger(triggerCount) && triggerCount >= 0 ? triggerCount : 0;
+  const types = triggerTypes && typeof triggerTypes === "object" ? triggerTypes : null;
+  for (const record of records) {
+    if (!isForgeKind(record?.kind)) continue;
+    const idx = record?.triggerIndex;
+    if (!Number.isInteger(idx) || idx < 0 || idx >= count) {
+      unattributed++;
+      continue;
+    }
+    if (types && (types[idx] === void 0 || types[idx] !== record.triggerType)) {
+      unattributed++;
+      continue;
+    }
+    const slot = byIndex[idx] ??= { runs: 0, lastOutcome: null, lastEndedAt: null };
+    slot.runs++;
+    const at = record.endedAt ?? record.startedAt ?? null;
+    if (at !== null && (slot.lastEndedAt === null || at > slot.lastEndedAt)) {
+      slot.lastEndedAt = at;
+      slot.lastOutcome = record.outcome ?? null;
+    }
+  }
+  return { byIndex, unattributed };
+}
+function observedChainEdges({ records } = {}) {
+  const empty = { edges: [], refusals: {}, truncated: false };
+  if (!Array.isArray(records)) return empty;
+  const byJobId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (typeof record?.jobId === "string" && record.jobId !== "") byJobId.set(record.jobId, record);
+  }
+  const folded = /* @__PURE__ */ new Map();
+  const refusals = {};
+  let truncated = false;
+  for (const child of records) {
+    const parentId = child?.parentJobId;
+    if (typeof parentId !== "string" || parentId === "") continue;
+    const parent = byJobId.get(parentId);
+    if (!parent) continue;
+    if (typeof parent.flow !== "string" || typeof child.flow !== "string") continue;
+    if (parent.target !== child.target) continue;
+    const key = `${parent.flow} ${child.flow} ${parent.target ?? ""}`;
+    let edge = folded.get(key);
+    if (!edge) {
+      if (folded.size >= GRAPH_LIMITS.maxEdges) {
+        truncated = true;
+        continue;
+      }
+      edge = { parentFlow: parent.flow, childFlow: child.flow, target: parent.target ?? null, count: 0, lastEndedAt: null };
+      folded.set(key, edge);
+    }
+    edge.count++;
+    const at = child.endedAt ?? child.startedAt ?? null;
+    if (at !== null && (edge.lastEndedAt === null || at > edge.lastEndedAt)) edge.lastEndedAt = at;
+  }
+  for (const record of records) {
+    if (Number.isInteger(record?.chainRefused) && record.chainRefused > 0 && typeof record?.flow === "string") {
+      const scope = typeof record.target === "string" && record.target.startsWith("local:") ? `${record.target.slice("local:".length)}/${record.flow}` : record.flow;
+      refusals[scope] = (refusals[scope] ?? 0) + record.chainRefused;
+    }
+  }
+  return { edges: [...folded.values()], refusals, truncated };
+}
+function readFolderSkills({ folder, exec: exec4 = execFileSync2 } = {}) {
+  const empty = { head: null, skills: [], truncated: false };
+  if (typeof folder !== "string" || folder === "") return { ...empty, unreachable: "no-folder" };
+  const head = revParseHead(folder, { exec: exec4 });
+  if (head === null) return { ...empty, unreachable: "not-a-git-repo" };
+  let listing;
+  try {
+    listing = exec4(
+      "git",
+      ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false", "--no-pager", "-C", folder, "ls-tree", "-r", "-l", "-z", head, ".pi/"],
+      { encoding: "utf8", maxBuffer: GRAPH_LS_TREE_MAX_BYTES }
+    );
+  } catch {
+    return { head, skills: [], truncated: false, unreachable: "ls-tree-failed" };
+  }
+  let kept;
+  try {
+    const selected = selectEntries(listing);
+    kept = keepOnlyDeclaredSkills(selected.entries).kept;
+  } catch {
+    return { head, skills: [], truncated: false, unreachable: "listing-unparseable" };
+  }
+  const topLevel = /* @__PURE__ */ new Map();
+  const subs = [];
+  for (const entry of kept) {
+    if (entry.skill === null || !entry.outRel.endsWith("/SKILL.md")) continue;
+    if (entry.outRel === `pi/skills/${entry.skill}/SKILL.md`) {
+      topLevel.set(entry.skill, entry);
+    } else {
+      subs.push({ name: entry.outRel.slice("pi/skills/".length, -"/SKILL.md".length), group: entry.skill });
+    }
+  }
+  const names = [...topLevel.keys()].sort();
+  const truncated = names.length > GRAPH_LIMITS.maxSkillsPerFolder;
+  const keptNames = names.slice(0, GRAPH_LIMITS.maxSkillsPerFolder);
+  const skills = [];
+  let anyUnread = false;
+  for (const name of keptNames) {
+    const entry = topLevel.get(name);
+    let text = null;
+    try {
+      const buf = exec4(
+        "git",
+        ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false", "--no-pager", "-C", folder, "cat-file", "blob", entry.oid],
+        { maxBuffer: GRAPH_LIMITS.maxSkillBytes }
+      );
+      text = buf.toString("utf8");
+    } catch {
+      anyUnread = true;
+    }
+    skills.push({
+      name,
+      isSub: false,
+      group: null,
+      // Fail-closed like the gate: an unreadable SKILL.md reads as not-chainable, never as chainable.
+      aiTrigger: text !== null && aiTriggerAllows(text),
+      meta: text !== null ? parseSkillMeta(text) : null,
+      mentions: text !== null ? findSiblingMentions(text.slice(0, GRAPH_LIMITS.maxMentionScanBytes), keptNames.filter((n) => n !== name)) : [],
+      // The prose-loop hints (issue #54's grouped-inside-the-skill visual): scanned over the same
+      // bounded window as the mentions, because both are text evidence of the same trust class.
+      loops: text !== null ? findLoopHints(text.slice(0, GRAPH_LIMITS.maxMentionScanBytes)) : [],
+      unread: text === null
+    });
+  }
+  for (const sub of subs.sort((a, b) => a.name < b.name ? -1 : 1)) {
+    skills.push({ name: sub.name, isSub: true, group: sub.group, aiTrigger: false, meta: null, mentions: [], unread: false });
+  }
+  return { head, skills, truncated: truncated || anyUnread, unreachable: null };
+}
+function readInjectedSkills({ skillsDir, fs = nodeFs2 } = {}) {
+  if (typeof skillsDir !== "string" || skillsDir === "") return { skills: [], truncated: false, unreachable: null };
+  let names;
+  try {
+    names = fs.readdirSync(skillsDir);
+  } catch {
+    return { skills: [], truncated: false, unreachable: "unreadable" };
+  }
+  const valid = names.filter((n) => SKILL_NAME_RE.test(n)).sort();
+  const truncated = valid.length > GRAPH_LIMITS.maxSkillsPerFolder;
+  const skills = [];
+  for (const name of valid.slice(0, GRAPH_LIMITS.maxSkillsPerFolder)) {
+    let aiTrigger = false;
+    try {
+      const text = fs.readFileSync(join2(skillsDir, name, "SKILL.md"), "utf8");
+      aiTrigger = aiTriggerAllows(text);
+    } catch {
+      continue;
+    }
+    skills.push({ name, aiTrigger });
+  }
+  return { skills, truncated, unreachable: null };
+}
+function collectGraphInputs({ triggers, readFolder = readFolderSkills, readInjected = readInjectedSkills } = {}) {
+  const out = { folderSkills: {}, injectedSkills: {}, foldersTruncated: false };
+  if (!Array.isArray(triggers)) return out;
+  const folders = [];
+  const injectedDirs = [];
+  for (const t of triggers) {
+    if (t?.type === "cron" && typeof t.folder === "string" && t.folder !== "" && !folders.includes(t.folder)) folders.push(t.folder);
+    if (typeof t?.skillsDir === "string" && t.skillsDir !== "" && !injectedDirs.includes(t.skillsDir)) injectedDirs.push(t.skillsDir);
+  }
+  out.foldersTruncated = folders.length > GRAPH_LIMITS.maxFoldersScanned;
+  for (const folder of folders.slice(0, GRAPH_LIMITS.maxFoldersScanned)) {
+    out.folderSkills[folder] = readFolder({ folder });
+  }
+  for (const dir of injectedDirs.slice(0, GRAPH_LIMITS.maxFoldersScanned)) {
+    out.injectedSkills[dir] = readInjected({ skillsDir: dir });
+  }
+  return out;
+}
+function forgeRepoTargets({ records } = {}) {
+  const byKind = {};
+  if (!Array.isArray(records)) return byKind;
+  for (const record of records) {
+    if (!isForgeKind(record?.kind) || typeof record?.target !== "string") continue;
+    const repo = record.target.replace(/[#!]\d+$/, "");
+    if (repo === "" || repo === record.target) continue;
+    (byKind[record.kind] ??= /* @__PURE__ */ new Set()).add(repo);
+  }
+  return Object.fromEntries(
+    Object.entries(byKind).map(([kind, set]) => [kind, [...set].sort().slice(0, GRAPH_LIMITS.maxReposListed)])
+  );
+}
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function listRunIds({ logsDir, fs = nodeFs2 }) {
   let names;
   try {
@@ -9267,7 +9990,7 @@ function clampLines(lines) {
   const n = Number.isFinite(lines) ? Math.floor(lines) : 200;
   return Math.min(2e3, Math.max(1, n));
 }
-var DISPATCH_RUN_TTL_SECONDS, SCAN_WINDOW_MAX_DAYS;
+var DISPATCH_RUN_TTL_SECONDS, SCAN_WINDOW_MAX_DAYS, GRAPH_LIMITS, GRAPH_LS_TREE_MAX_BYTES;
 var init_read_model = __esm({
   "src/read-model.mjs"() {
     init_config2();
@@ -9282,8 +10005,1058 @@ var init_read_model = __esm({
     init_flow_gate();
     init_git_dirty();
     init_packages();
+    init_materialize();
+    init_forges();
+    init_graph_model();
     DISPATCH_RUN_TTL_SECONDS = 2 * 60 * 60;
     SCAN_WINDOW_MAX_DAYS = 92;
+    GRAPH_LIMITS = Object.freeze({
+      maxFoldersScanned: 16,
+      // distinct cron folders enumerated per graph build; git spawns are the cost
+      maxSkillsPerFolder: 64,
+      // cat-file spawns per folder; mirrors PI_LIMITS.maxFilesPerSkill's altitude
+      maxSkillBytes: 64 * 1024,
+      // one SKILL.md read cap; frontmatter + prose, never a dataset
+      maxMentionScanBytes: 32 * 1024,
+      // sibling-name scan window into each SKILL.md
+      maxEdges: 200,
+      // distinct observed chain edges kept; beyond this the graph says "truncated"
+      windowDays: 30,
+      // run-record window the graph folds; matches the default PI_LOG_RETENTION_DAYS
+      maxReposListed: 5
+      // repos named per forge group, from record targets; a scope label, not an inventory
+    });
+    GRAPH_LS_TREE_MAX_BYTES = 1 << 20;
+  }
+});
+
+// src/graph-html.mjs
+function escapeHtml(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function embedJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function fmt(v) {
+  const n = Number.isFinite(v) ? Math.round(v * 10) / 10 : 0;
+  return String(n);
+}
+function finOr(v, fallback) {
+  return Number.isFinite(v) ? v : fallback;
+}
+function intOr(v, fallback) {
+  return Number.isInteger(v) ? v : fallback;
+}
+function strOr(v, fallback) {
+  return typeof v === "string" && v !== "" ? v : fallback;
+}
+function clip(s, max) {
+  const t = String(s);
+  return t.length > max ? `${t.slice(0, max)}\u2026` : t;
+}
+function normalizeModel(model) {
+  const ok = model !== null && typeof model === "object";
+  const m = ok ? model : {};
+  const caps = {
+    chainDepthMax: intOr(m.caps?.chainDepthMax, null),
+    chainMaxPerJob: intOr(m.caps?.chainMaxPerJob, null),
+    sameFolderOnly: m.caps?.sameFolderOnly !== false,
+    windowDays: intOr(m.caps?.windowDays, null)
+  };
+  const meta = {
+    generatedAt: finOr(m.meta?.generatedAt, null),
+    triggersMissing: m.meta?.triggersMissing === true,
+    triggersInvalid: typeof m.meta?.triggersInvalid === "string" ? m.meta.triggersInvalid : null,
+    unattributedRuns: intOr(m.meta?.unattributedRuns, 0),
+    droppedObservedEdges: intOr(m.meta?.droppedObservedEdges, 0),
+    truncated: {
+      folders: m.meta?.truncated?.folders === true,
+      skills: m.meta?.truncated?.skills === true,
+      edges: m.meta?.truncated?.edges === true
+    }
+  };
+  const folders = [];
+  for (const f of Array.isArray(m.folders) ? m.folders : []) {
+    if (!f || typeof f !== "object" || typeof f.key !== "string") continue;
+    folders.push({
+      key: f.key,
+      label: strOr(f.label, "(folder)"),
+      // The absolute host path rides the model but is RENDERED only under { fullPaths: true } (an
+      // operator opt-in); the default page stays basename-only, so a shared screenshot or artifact
+      // cannot leak home-directory names -- the canary test pins the default.
+      path: typeof f.path === "string" ? f.path : null,
+      kind: f.kind === "forge" ? "forge" : "local",
+      head: typeof f.head === "string" ? f.head : null,
+      unreachable: typeof f.unreachable === "string" ? f.unreachable : null,
+      // Record-derived scope for forge groups ("which repos is this group even about"); already
+      // id-only repo#n-style strings upstream, clipped and capped again here anyway.
+      repos: Array.isArray(f.repos) ? f.repos.slice(0, 5).filter((r) => typeof r === "string").map((r) => clip(r, 60)) : []
+    });
+  }
+  folders.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const n of Array.isArray(m.nodes) ? m.nodes : []) {
+    if (!n || typeof n !== "object" || typeof n.id !== "string" || seen.has(n.id)) continue;
+    seen.add(n.id);
+    nodes.push({
+      id: n.id,
+      kind: typeof n.kind === "string" ? n.kind : "skill",
+      name: typeof n.name === "string" ? n.name : null,
+      label: typeof n.label === "string" ? n.label : null,
+      onType: typeof n.onType === "string" ? n.onType : null,
+      pattern: typeof n.pattern === "string" ? n.pattern : null,
+      flow: typeof n.flow === "string" ? n.flow : null,
+      replicas: intOr(n.replicas, null),
+      folderKey: typeof n.folderKey === "string" ? n.folderKey : null,
+      runs: intOr(n.runs, 0),
+      lastOutcome: typeof n.lastOutcome === "string" ? n.lastOutcome : null,
+      lastEndedAt: typeof n.lastEndedAt === "string" || Number.isFinite(n.lastEndedAt) ? n.lastEndedAt : null,
+      isSub: n.isSub === true,
+      group: typeof n.group === "string" ? n.group : null,
+      // Prose-loop hints from the SKILL.md body; capped and clipped so a hostile skill cannot
+      // inflate its own group box into a page-filling banner.
+      loops: Array.isArray(n.loops) ? n.loops.slice(0, 3).flatMap((l) => typeof l?.hint === "string" && l.hint !== "" ? [{ hint: clip(l.hint, 80) }] : []) : [],
+      aiTrigger: n.aiTrigger === true,
+      unread: n.unread === true,
+      description: typeof n.meta?.description === "string" ? clip(n.meta.description, 120) : null
+    });
+  }
+  nodes.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const edges = [];
+  for (const e of Array.isArray(m.edges) ? m.edges : []) {
+    if (!e || typeof e !== "object") continue;
+    if (typeof e.from !== "string" || typeof e.to !== "string") continue;
+    if (!GRAPH_HTML_KINDS.includes(e.kind)) continue;
+    edges.push({
+      from: e.from,
+      to: e.to,
+      kind: e.kind,
+      count: intOr(e.count, null),
+      strong: e.strong === true,
+      eligible: e.eligible === true,
+      label: typeof e.label === "string" ? e.label : 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));
+  const flags = [];
+  for (const f of Array.isArray(m.flags) ? m.flags : []) {
+    if (!f || typeof f !== "object" || typeof f.nodeId !== "string" || typeof f.flag !== "string") continue;
+    flags.push({ nodeId: f.nodeId, flag: f.flag, detail: typeof f.detail === "string" ? clip(f.detail, 160) : null });
+  }
+  flags.sort((a, b) => cmpStr(a.nodeId, b.nodeId) || cmpStr(a.flag, b.flag) || cmpStr(a.detail ?? "", b.detail ?? ""));
+  return { ok, folders, nodes, edges, flags, caps, meta };
+}
+function cmpStr(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function chipLabel(n) {
+  if (n.kind === "trigger") return clip(n.label ?? n.onType ?? "trigger", CHIP_MAX_CHARS);
+  return clip(n.name ?? "(unnamed)", CHIP_MAX_CHARS);
+}
+function chipWidth(label) {
+  const raw = LABEL_X + label.length * CHAR_W + 12;
+  const snapped = Math.ceil(raw / GRID) * GRID;
+  return Math.min(NODE_MAX_W, Math.max(NODE_MIN_W, snapped));
+}
+function layoutNormalized(norm) {
+  const empty = { nodes: [], wires: [], groups: [], skillGroups: [], viewBox: { x: 0, y: 0, w: 800, h: 600 } };
+  if (!norm.ok && norm.nodes.length === 0) return empty;
+  const groups = [];
+  const groupIndexByKey = /* @__PURE__ */ new Map();
+  const addGroup = (key, label, kind, head, unreachable, path, repos) => {
+    const g = { id: `g${groups.length}`, label, kind, head, unreachable, path: path ?? null, repos: repos ?? [], members: [], x: 0, y: 0, w: 0, h: 0 };
+    groups.push(g);
+    groupIndexByKey.set(key, g);
+    return g;
+  };
+  for (const f of norm.folders) addGroup(f.key, f.label, f.kind, f.head, f.unreachable, f.path, f.repos);
+  const placed = [];
+  const placedByOrig = /* @__PURE__ */ new Map();
+  for (const n of norm.nodes) {
+    const label = chipLabel(n);
+    const p = { id: `n${placed.length}`, kind: n.kind, label, x: 0, y: 0, w: chipWidth(label), h: NODE_H, groupId: null, node: n };
+    placed.push(p);
+    placedByOrig.set(n.id, p);
+    let g = n.folderKey === null ? null : groupIndexByKey.get(n.folderKey) ?? null;
+    if (!g && n.kind === "injected") g = groupIndexByKey.get("~injected") ?? addGroup("~injected", "injected skills (run.skillsDir)", "local", null, null);
+    if (!g) g = groupIndexByKey.get(n.folderKey ?? "~ungrouped") ?? addGroup(n.folderKey ?? "~ungrouped", "ungrouped", "local", null, null);
+    g.members.push(p);
+    p.groupId = g.id;
+  }
+  const wires = [];
+  for (const e of norm.edges) {
+    const f = placedByOrig.get(e.from);
+    const t = placedByOrig.get(e.to);
+    if (!f || !t) continue;
+    wires.push({ id: `w${wires.length}`, kind: e.kind, from: f.id, to: t.id, self: f === t, back: false, edge: e, f, t, d: "", labelX: 0, labelY: 0 });
+  }
+  markBackEdges(placed, wires);
+  const skillGroups = [];
+  let groupY = 0;
+  let maxGroupW = 0;
+  for (const g of groups) {
+    const sgStart = skillGroups.length;
+    const size = layoutGroup(g, wires, skillGroups);
+    g.x = 0;
+    g.y = groupY;
+    g.w = size.w;
+    g.h = size.h;
+    for (const p of g.members) {
+      p.x += g.x;
+      p.y += g.y;
+    }
+    for (let i = sgStart; i < skillGroups.length; i++) {
+      const sg = skillGroups[i];
+      sg.x += g.x;
+      sg.y += g.y;
+      for (const m of sg.markers) {
+        m.x += g.x;
+        m.y += g.y;
+        m.hintX += g.x;
+        m.hintY += g.y;
+      }
+      sg.points = sg.points.map(([px, py]) => [px + g.x, py + g.y]);
+      sg.d = sg.points.map(([px, py], j) => `${j === 0 ? "M" : "L"} ${fmt(px)} ${fmt(py)}`).join(" ");
+    }
+    groupY += g.h + GROUP_GAP;
+    if (g.w > maxGroupW) maxGroupW = g.w;
+  }
+  const parallelCount = /* @__PURE__ */ new Map();
+  for (const w of wires) {
+    const key = `${w.from} ${w.to}`;
+    w.parallel = parallelCount.get(key) ?? 0;
+    parallelCount.set(key, w.parallel + 1);
+  }
+  for (const w of wires) routeWire(w);
+  for (const w of wires) {
+    delete w.f;
+    delete w.t;
+  }
+  const totalH = groups.length > 0 ? groupY - GROUP_GAP : 0;
+  const viewBox = groups.length > 0 ? { x: -VIEW_MARGIN, y: -VIEW_MARGIN, w: maxGroupW + VIEW_MARGIN * 2, h: totalH + VIEW_MARGIN * 2 } : { x: 0, y: 0, w: 800, h: 600 };
+  return { nodes: placed, wires, groups, skillGroups, viewBox };
+}
+function markBackEdges(placed, wires) {
+  const out = /* @__PURE__ */ new Map();
+  for (const w of wires) {
+    if (w.self) continue;
+    if (!out.has(w.from)) out.set(w.from, []);
+    out.get(w.from).push(w);
+  }
+  for (const list of out.values()) list.sort((a, b) => cmpStr(a.to, b.to) || cmpStr(a.id, b.id));
+  const state = /* @__PURE__ */ new Map();
+  for (const p of placed) {
+    if (state.has(p.id)) continue;
+    const stack = [{ id: p.id, i: 0 }];
+    state.set(p.id, 1);
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      const edges = out.get(top.id) ?? [];
+      if (top.i >= edges.length) {
+        state.set(top.id, 2);
+        stack.pop();
+        continue;
+      }
+      const w = edges[top.i++];
+      const s = state.get(w.to);
+      if (s === 1) w.back = true;
+      else if (s !== 2) {
+        state.set(w.to, 1);
+        stack.push({ id: w.to, i: 0 });
+      }
+    }
+  }
+}
+function layoutGroup(g, allWires, sgOut) {
+  const members = g.members;
+  if (members.length === 0) return { w: GROUP_PAD_L + NODE_MAX_W + GROUP_PAD_R, h: GROUP_PAD_T + GROUP_PAD_B };
+  const subsByParent = /* @__PURE__ */ new Map();
+  const grid = [];
+  for (const p of members) {
+    if (p.node.isSub && typeof p.node.group === "string") {
+      if (!subsByParent.has(p.node.group)) subsByParent.set(p.node.group, []);
+      subsByParent.get(p.node.group).push(p);
+    } else {
+      grid.push(p);
+    }
+  }
+  const parentByName = /* @__PURE__ */ new Map();
+  for (const p of grid) {
+    if (p.kind === "skill" && p.node.name !== null && !parentByName.has(p.node.name)) parentByName.set(p.node.name, p);
+  }
+  for (const [name, subs] of subsByParent) {
+    if (!parentByName.has(name)) for (const s of subs) grid.push(s);
+  }
+  const supers = /* @__PURE__ */ new Map();
+  for (const p of grid) {
+    if (p.kind !== "skill") continue;
+    const subs = parentByName.get(p.node.name) === p ? subsByParent.get(p.node.name) ?? [] : [];
+    if (p.node.loops.length === 0 && subs.length === 0) continue;
+    supers.set(p.id, computeSkillGroup(p, p.node.loops, subs));
+  }
+  const effW = (p) => supers.has(p.id) ? supers.get(p.id).w : p.w;
+  const effH = (p) => supers.has(p.id) ? supers.get(p.id).h : p.h;
+  const gridSet = new Set(grid.map((p) => p.id));
+  const rankEdges = allWires.filter((w) => !w.self && !w.back && gridSet.has(w.from) && gridSet.has(w.to));
+  const rank = /* @__PURE__ */ new Map();
+  for (const p of grid) rank.set(p.id, p.kind === "trigger" ? 0 : 1);
+  for (let i = 0; i < grid.length; i++) {
+    let changed = false;
+    for (const w of rankEdges) {
+      if (w.t.kind === "trigger") continue;
+      const want = rank.get(w.from) + 1;
+      if (rank.get(w.to) < want) {
+        rank.set(w.to, want);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  const maxRank = Math.max(...[...rank.values()]);
+  const rows = [];
+  for (let r = 0; r <= maxRank; r++) rows.push([]);
+  for (const p of grid) rows[rank.get(p.id)].push(p);
+  for (const row of rows) row.sort((a, b) => cmpStr(a.label, b.label) || cmpStr(a.id, b.id));
+  orderRows(rows, rankEdges);
+  const rankMaxW = [];
+  for (let r = 0; r <= maxRank; r++) rankMaxW.push(Math.max(NODE_MAX_W, ...rows[r].map(effW)));
+  const colX = [GROUP_PAD_L];
+  for (let r = 1; r <= maxRank; r++) colX.push(colX[r - 1] + Math.max(RANK_PITCH, rankMaxW[r - 1] + 20));
+  const underIds = /* @__PURE__ */ new Set();
+  for (const w of allWires) {
+    if (w.self && gridSet.has(w.from)) underIds.add(w.from);
+    if (w.back) {
+      if (gridSet.has(w.from)) underIds.add(w.from);
+      if (gridSet.has(w.to)) underIds.add(w.to);
+    }
+  }
+  const maxRows = Math.max(...rows.map((row) => row.length));
+  const rowY = [];
+  let y = GROUP_PAD_T;
+  for (let i = 0; i < maxRows; i++) {
+    rowY.push(y);
+    const band = rows.flatMap((row) => row.length > i ? [row[i]] : []);
+    const bandH = Math.max(NODE_H, ...band.map(effH));
+    const under = band.some((p) => underIds.has(p.id));
+    y += bandH + (under ? UNDER_ROUTE_EXTRA : 0) + ROW_GAP;
+  }
+  for (let r = 0; r <= maxRank; r++) {
+    for (let i = 0; i < rows[r].length; i++) {
+      const p = rows[r][i];
+      if (supers.has(p.id)) {
+        placeSkillGroup(g, p, supers.get(p.id), colX[r], rowY[i], sgOut);
+      } else {
+        p.x = colX[r];
+        p.y = rowY[i];
+      }
+    }
+  }
+  return {
+    w: colX[maxRank] + rankMaxW[maxRank] + GROUP_PAD_R,
+    h: y - ROW_GAP + GROUP_PAD_B
+  };
+}
+function computeSkillGroup(p, loops, subs) {
+  let cy = SG_CHIP_Y + NODE_H + 14;
+  const markers = [];
+  for (const l of loops.slice(0, 3)) {
+    markers.push({ x: SG_CHIP_X, y: cy, w: SG_MARKER, h: SG_MARKER, hint: clip(l.hint, SG_HINT_CHARS), hintX: SG_CHIP_X + SG_MARKER + 6, hintY: cy + 24 });
+    cy += SG_MARKER + 8;
+  }
+  const subPlaced = [];
+  for (const s of subs) {
+    const label = clip(s.node.name ?? "(sub)", 16);
+    s.label = label;
+    s.w = Math.min(140, Math.max(80, 12 + label.length * 7));
+    s.h = SUB_CHIP_H;
+    s.nested = true;
+    subPlaced.push({ p: s, x: SG_CHIP_X, y: cy });
+    cy += SUB_CHIP_H + 6;
+  }
+  const wCandidates = [SG_CHIP_X + p.w + 18];
+  if (markers.length > 0) wCandidates.push(SG_CHIP_X + SG_MARKER + 6 + SG_HINT_CHARS * SG_SMALL_CHAR_W + 14);
+  for (const s of subPlaced) wCandidates.push(SG_CHIP_X + s.p.w + 18);
+  const w = Math.max(...wCandidates);
+  const h = cy + 8;
+  const py = SG_CHIP_Y + NODE_H / 2;
+  const points = [
+    [SG_CHIP_X + p.w, py],
+    [w - SG_RING, py],
+    [w - SG_RING, h - SG_RING],
+    [SG_RING, h - SG_RING],
+    [SG_RING, py],
+    [SG_CHIP_X, py]
+  ];
+  return { w, h, markers, subPlaced, points };
+}
+function placeSkillGroup(g, p, box2, x, y, sgOut) {
+  p.x = x + SG_CHIP_X;
+  p.y = y + SG_CHIP_Y;
+  const markers = box2.markers.map((m) => ({ ...m, x: m.x + x, y: m.y + y, hintX: m.hintX + x, hintY: m.hintY + y }));
+  for (const s of box2.subPlaced) {
+    s.p.x = x + s.x;
+    s.p.y = y + s.y;
+  }
+  sgOut.push({
+    id: `sg${sgOut.length}`,
+    groupId: g.id,
+    nodeId: p.id,
+    label: p.node.name ?? p.label,
+    x,
+    y,
+    w: box2.w,
+    h: box2.h,
+    markers,
+    subIds: box2.subPlaced.map((s) => s.p.id),
+    points: box2.points.map(([px, py]) => [px + x, py + y]),
+    d: ""
+  });
+}
+function orderRows(rows, rankEdges) {
+  const pos = /* @__PURE__ */ new Map();
+  const setPos = (row) => row.forEach((p, i) => pos.set(p.id, i));
+  for (const row of rows) setPos(row);
+  const preds = /* @__PURE__ */ new Map();
+  const succs = /* @__PURE__ */ new Map();
+  for (const w of rankEdges) {
+    if (!preds.has(w.to)) preds.set(w.to, []);
+    preds.get(w.to).push(w.from);
+    if (!succs.has(w.from)) succs.set(w.from, []);
+    succs.get(w.from).push(w.to);
+  }
+  const median = (ids) => {
+    const xs = (ids ?? []).map((id) => pos.get(id)).filter((v) => Number.isInteger(v)).sort((a, b) => a - b);
+    return xs.length === 0 ? null : xs[xs.length - 1 >> 1];
+  };
+  const sweep = (nbrs, indices) => {
+    for (const r of indices) {
+      const keyed = rows[r].map((p, i) => ({ p, key: median(nbrs.get(p.id)) ?? i }));
+      keyed.sort((a, b) => a.key - b.key || cmpStr(a.p.label, b.p.label) || cmpStr(a.p.id, b.p.id));
+      rows[r] = keyed.map((k) => k.p);
+      setPos(rows[r]);
+    }
+  };
+  const down = [];
+  const up = [];
+  for (let r = 1; r < rows.length; r++) down.push(r);
+  for (let r = rows.length - 2; r >= 0; r--) up.push(r);
+  sweep(preds, down);
+  sweep(succs, up);
+}
+function routeWire(w) {
+  const f = w.f;
+  const t = w.t;
+  const y1 = f.y + NODE_H / 2;
+  const y2 = t.y + NODE_H / 2;
+  const LOOP_OFF = 18;
+  if (w.self) {
+    const x12 = f.x + f.w;
+    const x22 = f.x;
+    const yb = f.y + NODE_H + SELF_LOOP_DROP + w.parallel * 12;
+    w.d = `M ${fmt(x12)} ${fmt(y1)} C ${fmt(x12 + LOOP_OFF)} ${fmt(y1)}, ${fmt(x12 + LOOP_OFF)} ${fmt(yb)}, ${fmt(x12)} ${fmt(yb)} L ${fmt(x22)} ${fmt(yb)} C ${fmt(x22 - LOOP_OFF)} ${fmt(yb)}, ${fmt(x22 - LOOP_OFF)} ${fmt(y2)}, ${fmt(x22)} ${fmt(y2)}`;
+    w.labelX = f.x + f.w / 2;
+    w.labelY = yb + 12;
+    return;
+  }
+  if (w.back) {
+    const x12 = f.x + f.w;
+    const x22 = t.x;
+    const yb = Math.max(f.y, t.y) + NODE_H + SELF_LOOP_DROP + 10 + w.parallel * 12;
+    w.d = `M ${fmt(x12)} ${fmt(y1)} C ${fmt(x12 + LOOP_OFF)} ${fmt(y1)}, ${fmt(x12 + LOOP_OFF)} ${fmt(yb)}, ${fmt(x12)} ${fmt(yb)} L ${fmt(x22)} ${fmt(yb)} C ${fmt(x22 - LOOP_OFF)} ${fmt(yb)}, ${fmt(x22 - LOOP_OFF)} ${fmt(y2)}, ${fmt(x22)} ${fmt(y2)}`;
+    w.labelX = (x12 + x22) / 2;
+    w.labelY = yb + 12;
+    return;
+  }
+  const x1 = f.x + f.w;
+  const x2 = t.x;
+  const dx = Math.max(x2 - x1, 4);
+  const sc = dx < 100 ? 0.75 * (dx / 100) : 0.75;
+  const off = Math.max(dx * sc, 10);
+  const sign = w.parallel % 2 === 1 ? -1 : 1;
+  const steps = Math.ceil(w.parallel / 2);
+  const bow = sign * steps * PARALLEL_BOW;
+  w.d = `M ${fmt(x1)} ${fmt(y1)} C ${fmt(x1 + off)} ${fmt(y1 + bow)}, ${fmt(x2 - off)} ${fmt(y2 + bow)}, ${fmt(x2)} ${fmt(y2)}`;
+  w.labelX = (x1 + x2) / 2;
+  if (x2 - x1 < LABEL_MIN_SPAN) {
+    w.labelY = Math.min(y1, y2) - 12 - w.parallel * 12;
+  } else {
+    w.labelY = (y1 + y2) / 2 - 5 + sign * steps * PARALLEL_LABEL_STEP;
+  }
+}
+function relTime(nowMs, v) {
+  const t = typeof v === "number" ? v : typeof v === "string" ? Date.parse(v) : null;
+  if (!Number.isFinite(t) || !Number.isFinite(nowMs)) return null;
+  const s = Math.max(0, Math.floor((nowMs - t) / 1e3));
+  if (s < 60) return `${s}s ago`;
+  const mn = Math.floor(s / 60);
+  if (mn < 60) return `${mn}m ago`;
+  const h = Math.floor(mn / 60);
+  if (h < 48) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+function buildTip(n, flags, groupLabel, nowMs) {
+  const lines = [];
+  if (n.kind === "trigger") {
+    lines.push(`trigger \xB7 ${n.onType ?? "?"} \xB7 ${n.label ?? ""}`.trim());
+    if (n.flow !== null) lines.push(`flow: ${n.flow}${n.replicas !== null ? ` \xD7${n.replicas}` : ""}`);
+  } else if (n.kind === "injected") {
+    lines.push(`injected skill \xB7 ${n.name ?? "?"}`);
+    lines.push("trigger-reachable via run.skillsDir, never AI-reachable");
+  } else if (n.kind === "skill-missing") {
+    lines.push(`skill \xB7 ${n.name ?? "?"} \xB7 missing at HEAD`);
+  } else if (n.kind === "skill-unverified") {
+    lines.push(`skill \xB7 ${n.name ?? "?"} \xB7 unverified (repo not readable from this host)`);
+  } else {
+    lines.push(`skill \xB7 ${n.name ?? "?"}${n.isSub ? " \xB7 sub-skill (never a flow)" : ""}`);
+  }
+  if (groupLabel !== null) lines.push(`folder: ${groupLabel}`);
+  if (n.description !== null) lines.push(n.description);
+  if (n.kind === "trigger") {
+    if (n.runs > 0) {
+      const rel = relTime(nowMs, n.lastEndedAt);
+      lines.push(`runs: ${n.runs}${n.lastOutcome !== null ? ` \xB7 last ${n.lastOutcome}${rel !== null ? ` ${rel}` : ""}` : ""}`);
+    } else {
+      lines.push("no runs in window");
+    }
+  }
+  if (n.aiTrigger) lines.push("chainable: ai-trigger allow");
+  if (n.kind === "skill" && n.loops.length > 0) {
+    lines.push(`loops in skill: ${n.loops.map((l) => l.hint).join(" \xB7 ")}`);
+  }
+  for (const f of flags) lines.push(f.detail !== null ? `${f.flag}: ${f.detail}` : f.flag);
+  return lines.join("\n");
+}
+function groupTitle(g, fullPaths) {
+  if (g.kind === "forge") {
+    const scope = Array.isArray(g.repos) && g.repos.length > 0 ? ` \xB7 ran against ${g.repos.join(", ")}` : "";
+    return `${g.label}${scope} \xB7 forge \xB7 unverifiable from this host`;
+  }
+  const name = fullPaths === true && typeof g.path === "string" && g.path !== "" ? g.path : g.label;
+  if (g.unreachable !== null && g.unreachable !== void 0 && g.unreachable !== "") return `${name} \xB7 ${g.unreachable}`;
+  if (g.head !== null && g.head !== void 0 && g.head !== "") return `${name} \xB7 HEAD ${String(g.head).slice(0, 7)}`;
+  return name;
+}
+function capsLineText(caps) {
+  const d = caps.chainDepthMax ?? "?";
+  const m = caps.chainMaxPerJob ?? "?";
+  const k = caps.windowDays ?? "?";
+  return `chains: depth \u2264 ${d} \xB7 \u2264 ${m} per job \xB7 same folder only \xB7 window ${k}d`;
+}
+function nodeState(n, flagNames) {
+  if (n.kind === "skill-missing" || [...flagNames].some((f) => DANGLING_FLAGS.has(f))) {
+    return { stroke: DANGER, dash: "10,4", faded: false };
+  }
+  if (n.kind === "skill-unverified") return { stroke: PAGE_DIM, dash: "10,4", faded: false };
+  if (flagNames.has("orphan")) return { stroke: CHIP_STROKE, dash: "8,3", faded: true };
+  return { stroke: CHIP_STROKE, dash: null, faded: false };
+}
+function chipFill(n) {
+  if (n.kind === "trigger") return CHIP_FILL[n.onType] ?? PORT_FILL;
+  return CHIP_FILL.skill;
+}
+function chipGlyph(n) {
+  if (n.kind === "trigger") return GLYPH[n.onType] ?? "\u2022";
+  return GLYPH[n.kind] ?? GLYPH.skill;
+}
+function statusColor(outcome) {
+  if (outcome === "completed") return STATUS_COMPLETED;
+  if (outcome === "failed") return STATUS_FAILED;
+  return STATUS_OTHER;
+}
+function nodeSvg(p, flags, hasIn, hasOut) {
+  const n = p.node;
+  if (p.nested === true) {
+    return [
+      `<g class="gnode" id="${p.id}" transform="translate(${fmt(p.x)},${fmt(p.y)})">`,
+      `<rect width="${fmt(p.w)}" height="${fmt(p.h)}" rx="4" fill="${CHIP_FILL.skill}" stroke="${CHIP_STROKE}" stroke-width="1"/>`,
+      `<text x="8" y="16" font-size="11" fill="${CHIP_LABEL}">${escapeHtml(p.label)}</text>`,
+      "</g>"
+    ].join("");
+  }
+  const flagNames = new Set(flags.map((f) => f.flag));
+  const state = nodeState(n, flagNames);
+  const parts = [`<g class="gnode" id="${p.id}" transform="translate(${fmt(p.x)},${fmt(p.y)})">`];
+  parts.push(
+    `<rect width="${fmt(p.w)}" height="${fmt(NODE_H)}" rx="5" fill="${chipFill(n)}"${state.faded ? ' fill-opacity=".5"' : ""} stroke="${state.stroke}" stroke-width="1"${state.dash !== null ? ` stroke-dasharray="${state.dash}"` : ""}/>`
+  );
+  parts.push(`<path d="M 30 1 L 30 29" stroke="${CHIP_STROKE}" stroke-width="1" opacity=".5"/>`);
+  parts.push(`<text x="15" y="20" text-anchor="middle" font-size="13" fill="${CHIP_LABEL}">${escapeHtml(chipGlyph(n))}</text>`);
+  parts.push(`<text x="${LABEL_X}" y="20" font-size="14" fill="${CHIP_LABEL}">${escapeHtml(p.label)}</text>`);
+  if (hasIn) parts.push(`<rect x="-5" y="${fmt(NODE_H / 2 - 5)}" width="10" height="10" rx="3" fill="${PORT_FILL}" stroke="${CHIP_STROKE}" stroke-width="1"/>`);
+  if (hasOut) parts.push(`<rect x="${fmt(p.w - 5)}" y="${fmt(NODE_H / 2 - 5)}" width="10" height="10" rx="3" fill="${PORT_FILL}" stroke="${CHIP_STROKE}" stroke-width="1"/>`);
+  if (n.kind === "trigger") {
+    parts.push(`<rect x="3" y="${fmt(NODE_H + 3)}" width="9" height="9" rx="2" fill="${statusColor(n.runs > 0 ? n.lastOutcome : null)}"/>`);
+    parts.push(`<text x="16" y="${fmt(NODE_H + 11)}" font-size="10" fill="${PAGE_DIM}">${n.runs > 0 ? `${fmt(n.runs)} runs` : "no runs"}</text>`);
+  }
+  const orange = [...flagNames].some((f) => ORANGE_FLAGS.has(f));
+  if (orange) parts.push(`<circle cx="${fmt(p.w - 4)}" cy="-2" r="5" fill="${BADGE_ORANGE}"/>`);
+  if (n.aiTrigger) parts.push(`<circle cx="${fmt(p.w - 4 - (orange ? 14 : 0))}" cy="-2" r="4" fill="none" stroke="${BADGE_GREEN}" stroke-width="2"/>`);
+  parts.push("</g>");
+  return parts.join("");
+}
+function wireStyle(w) {
+  if (w.kind === "observed") return { stroke: WIRE_OBSERVED, width: 3, dash: null };
+  if (w.kind === "config") return { stroke: WIRE_CONFIG, width: 2, dash: null };
+  if (w.kind === "potential") return { stroke: w.edge.strong ? PAGE_ACCENT : WIRE_POTENTIAL, width: 2, dash: "6,4" };
+  return { stroke: CHIP_FILL.cron, width: 2, dash: "4,3" };
+}
+function wireSvg(w) {
+  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}\xD7)`;
+    fill = WIRE_OBSERVED;
+  } else if (w.kind === "potential") {
+    label = "mention";
+    fill = w.edge.strong ? PAGE_ACCENT : WIRE_POTENTIAL;
+  } else if (w.kind === "cron-rearm" && w.edge.label !== null) {
+    label = w.edge.label;
+    fill = CHIP_FILL.cron;
+  }
+  if (label !== null) parts.push(`<text x="${fmt(w.labelX)}" y="${fmt(w.labelY)}" text-anchor="middle" font-size="10" fill="${fill}">${escapeHtml(label)}</text>`);
+  parts.push("</g>");
+  return parts.join("");
+}
+function groupSvg(g, fullPaths) {
+  const opacity = g.kind === "forge" ? "0.03" : "0.06";
+  return [
+    `<g class="ggroup">`,
+    `<rect x="${fmt(g.x)}" y="${fmt(g.y)}" width="${fmt(g.w)}" height="${fmt(g.h)}" rx="2" fill="${GROUP_FILL}" fill-opacity="${opacity}" stroke="${PAGE_BORDER}" stroke-width="2"/>`,
+    `<text x="${fmt(g.x + 8)}" y="${fmt(g.y + 18)}" font-size="11" fill="${PAGE_DIM}">${escapeHtml(groupTitle(g, fullPaths))}</text>`,
+    `</g>`
+  ].join("");
+}
+function skillGroupSvg(sg) {
+  const parts = [`<g class="sgroup" id="${sg.id}">`];
+  parts.push(`<rect x="${fmt(sg.x)}" y="${fmt(sg.y)}" width="${fmt(sg.w)}" height="${fmt(sg.h)}" rx="2" fill="${GROUP_FILL}" fill-opacity="0.08" stroke="${PAGE_BORDER}" stroke-width="2"/>`);
+  parts.push(`<text x="${fmt(sg.x + 8)}" y="${fmt(sg.y + 16)}" font-size="11" fill="${PAGE_DIM}">${escapeHtml(sg.label)}</text>`);
+  parts.push(`<path d="${sg.d}" fill="none" stroke="${WIRE_POTENTIAL}" stroke-width="1.5" stroke-dasharray="4,3"/>`);
+  for (const m of sg.markers) {
+    parts.push(`<rect x="${fmt(m.x)}" y="${fmt(m.y)}" width="${fmt(m.w)}" height="${fmt(m.h)}" rx="6" fill="${CHIP_FILL.skill}" stroke="${CHIP_STROKE}" stroke-width="1"/>`);
+    parts.push(`<text x="${fmt(m.x + m.w / 2)}" y="${fmt(m.y + m.h / 2 + 6)}" text-anchor="middle" font-size="16" fill="${CHIP_LABEL}">\u27F3</text>`);
+    parts.push(`<text x="${fmt(m.hintX)}" y="${fmt(m.hintY)}" font-size="10" fill="${PAGE_DIM}">${escapeHtml(m.hint)}</text>`);
+  }
+  parts.push("</g>");
+  return parts.join("");
+}
+function legendSample(stroke, width, dash) {
+  return `<svg width="46" height="10" aria-hidden="true"><path d="M 2 5 C 16 5, 30 5, 44 5" fill="none" stroke="${stroke}" stroke-width="${fmt(width)}"${dash !== null ? ` stroke-dasharray="${dash}"` : ""}/></svg>`;
+}
+function legendSwatch(inner) {
+  return `<svg width="16" height="12" aria-hidden="true">${inner}</svg>`;
+}
+function legendHtml(norm) {
+  const rows = [];
+  const row = (sample, text) => rows.push(`<div class="row">${sample}<span>${escapeHtml(text)}</span></div>`);
+  rows.push("<h2>edges</h2>");
+  row(legendSample(WIRE_CONFIG, 2, null), "config: the trigger names this flow");
+  row(legendSample(WIRE_OBSERVED, 3, null), "observed \xD7n: chained in run records");
+  row(legendSample(WIRE_POTENTIAL, 2, "6,4"), "potential: a text mention, not a promise");
+  row(legendSample(PAGE_ACCENT, 2, "6,4"), "potential (strong): near chain vocabulary");
+  row(legendSample(CHIP_FILL.cron, 2, "4,3"), "cron re-arm: the schedule itself");
+  rows.push("<h2>badges</h2>");
+  row(legendSwatch(`<circle cx="8" cy="6" r="5" fill="${BADGE_ORANGE}"/>`), "unread / injected ai-trigger / PR spend-loop risk");
+  row(legendSwatch(`<circle cx="8" cy="6" r="4" fill="none" stroke="${BADGE_GREEN}" stroke-width="2"/>`), "chainable: ai-trigger allow");
+  row(legendSwatch(`<rect x="1" y="1" width="14" height="10" rx="2" fill="none" stroke="${CHIP_STROKE}" stroke-dasharray="8,3"/>`), "orphan: no trigger, no ai-trigger, no mention");
+  row(legendSwatch(`<rect x="1" y="1" width="14" height="10" rx="2" fill="none" stroke="${DANGER}" stroke-dasharray="10,4"/>`), "dangling: flow absent or name invalid");
+  row(legendSwatch(`<rect x="1" y="1" width="14" height="10" rx="2" fill="none" stroke="${PAGE_DIM}" stroke-dasharray="10,4"/>`), "unverified: repo not readable from this host");
+  rows.push(`<div class="caps">${escapeHtml(capsLineText(norm.caps))}</div>`);
+  const honesty = [];
+  if (norm.meta.unattributedRuns > 0) honesty.push(`${norm.meta.unattributedRuns} runs unattributed`);
+  if (norm.meta.truncated.folders) honesty.push("folder scan truncated (cap reached)");
+  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)`);
+  for (const line of honesty) rows.push(`<div class="honesty">${escapeHtml(line)}</div>`);
+  return `<div id="legend">${rows.join("")}</div>`;
+}
+function bannersHtml(norm) {
+  const banners = [];
+  if (!norm.ok) banners.push("no graph model supplied; the page has nothing to draw");
+  if (norm.meta.triggersMissing) banners.push("no triggers file found");
+  if (norm.meta.triggersInvalid !== null) banners.push(`triggers file invalid: ${norm.meta.triggersInvalid}`);
+  if (banners.length === 0) return "";
+  return `<div id="banners">${banners.map((b) => `<div class="banner">${escapeHtml(b)}</div>`).join("")}</div>`;
+}
+function buildGraphHtml(model, { now, fullPaths } = {}) {
+  let norm;
+  try {
+    norm = normalizeModel(model);
+  } catch {
+    norm = normalizeModel(null);
+  }
+  const layout = layoutNormalized(norm);
+  const nowMs = Number.isFinite(now) ? now : norm.meta.generatedAt ?? 0;
+  const flagsByOrig = /* @__PURE__ */ new Map();
+  for (const f of norm.flags) {
+    if (!flagsByOrig.has(f.nodeId)) flagsByOrig.set(f.nodeId, []);
+    flagsByOrig.get(f.nodeId).push(f);
+  }
+  const groupById = new Map(layout.groups.map((g) => [g.id, g]));
+  const hasIn = /* @__PURE__ */ new Set();
+  const hasOut = /* @__PURE__ */ new Set();
+  const adj = /* @__PURE__ */ new Map();
+  const touch = (id) => {
+    if (!adj.has(id)) adj.set(id, { nb: /* @__PURE__ */ new Set(), w: /* @__PURE__ */ new Set() });
+    return adj.get(id);
+  };
+  for (const w of layout.wires) {
+    hasOut.add(w.from);
+    hasIn.add(w.to);
+    touch(w.from).nb.add(w.to);
+    touch(w.from).w.add(w.id);
+    touch(w.to).nb.add(w.from);
+    touch(w.to).w.add(w.id);
+  }
+  const graphData = { nodes: {} };
+  const nodeParts = [];
+  for (const p of layout.nodes) {
+    const n = p.node;
+    const flags = norm.nodes.length > 0 ? findFlags(flagsByOrig, norm.nodes, p) : [];
+    const group = groupById.get(p.groupId);
+    const drawIn = hasIn.has(p.id) || n.kind !== "trigger" && n.kind !== "injected";
+    const drawOut = hasOut.has(p.id) || n.kind === "trigger";
+    nodeParts.push(nodeSvg(p, flags, drawIn, drawOut));
+    const a = adj.get(p.id);
+    graphData.nodes[p.id] = {
+      tip: buildTip(n, flags, group ? group.label : null, nowMs),
+      nb: a ? [...a.nb].sort() : [],
+      w: a ? [...a.w].sort() : []
+    };
+  }
+  const svgBody = [
+    layout.groups.map((g) => groupSvg(g, fullPaths)).join(""),
+    layout.skillGroups.map(skillGroupSvg).join(""),
+    layout.wires.map(wireSvg).join(""),
+    nodeParts.join("")
+  ].join("");
+  const vb = layout.viewBox;
+  const svgEl = [
+    `<svg id="graph" class="canvas" viewBox="${fmt(vb.x)} ${fmt(vb.y)} ${fmt(vb.w)} ${fmt(vb.h)}" role="img" aria-label="pi-dispatch trigger and flow graph" preserveAspectRatio="xMidYMid meet">`,
+    `<g id="root">${svgBody}</g>`,
+    `</svg>`
+  ].join("");
+  return [
+    "<!doctype html>",
+    '<meta charset="utf-8">',
+    "<title>pi-dispatch graph</title>",
+    `<style>${PAGE_CSS}</style>`,
+    "<body>",
+    '<div id="hdr">',
+    "<h1>pi-dispatch graph</h1>",
+    '<span id="stamp"></span>',
+    '<button id="reload" type="button">Reload</button>',
+    '<select id="auto" aria-label="auto reload"><option value="0">off</option><option value="5">5s</option><option value="30">30s</option></select>',
+    "</div>",
+    bannersHtml(norm),
+    `<div id="wrap">${svgEl}<div id="tip"></div></div>`,
+    legendHtml(norm),
+    `<script>
+"use strict";
+var GENERATED_AT = ${fmt(nowMs)};
+var GRAPH = ${embedJson(graphData)};
+${PAGE_JS}</script>`,
+    "</body>"
+  ].join("\n");
+}
+function findFlags(flagsByOrig, _nodes, placed) {
+  return flagsByOrig.get(placed.node.id) ?? [];
+}
+var GRAPH_HTML_KINDS, NODE_H, NODE_MIN_W, GRID, NODE_MAX_W, CHAR_W, LABEL_X, CHIP_MAX_CHARS, RANK_PITCH, ROW_GAP, GROUP_PAD_L, GROUP_PAD_R, GROUP_PAD_T, GROUP_PAD_B, GROUP_GAP, SELF_LOOP_DROP, UNDER_ROUTE_EXTRA, PARALLEL_BOW, PARALLEL_LABEL_STEP, LABEL_MIN_SPAN, SG_CHIP_X, SG_CHIP_Y, SG_RING, SG_MARKER, SG_HINT_CHARS, SG_SMALL_CHAR_W, SUB_CHIP_H, VIEW_MARGIN, PAGE_CANVAS, PAGE_PANEL, PAGE_BORDER, PAGE_FG, PAGE_DIM, PAGE_ACCENT, PAGE_AMBER, CHIP_STROKE, CHIP_LABEL, PORT_FILL, CHIP_FILL, STATUS_COMPLETED, STATUS_FAILED, STATUS_OTHER, BADGE_ORANGE, BADGE_GREEN, DANGER, GROUP_FILL, WIRE_OBSERVED, WIRE_CONFIG, WIRE_POTENTIAL, GLYPH, ORANGE_FLAGS, DANGLING_FLAGS, PAGE_CSS, PAGE_JS;
+var init_graph_html = __esm({
+  "src/graph-html.mjs"() {
+    GRAPH_HTML_KINDS = Object.freeze(["config", "observed", "potential", "cron-rearm"]);
+    NODE_H = 30;
+    NODE_MIN_W = 100;
+    GRID = 20;
+    NODE_MAX_W = 160;
+    CHAR_W = 8;
+    LABEL_X = 38;
+    CHIP_MAX_CHARS = 14;
+    RANK_PITCH = 180;
+    ROW_GAP = 26;
+    GROUP_PAD_L = 20;
+    GROUP_PAD_R = 20;
+    GROUP_PAD_T = 40;
+    GROUP_PAD_B = 44;
+    GROUP_GAP = 40;
+    SELF_LOOP_DROP = 25;
+    UNDER_ROUTE_EXTRA = 40;
+    PARALLEL_BOW = 14;
+    PARALLEL_LABEL_STEP = 10.5;
+    LABEL_MIN_SPAN = 40;
+    SG_CHIP_X = 22;
+    SG_CHIP_Y = 26;
+    SG_RING = 10;
+    SG_MARKER = 40;
+    SG_HINT_CHARS = 24;
+    SG_SMALL_CHAR_W = 6;
+    SUB_CHIP_H = 24;
+    VIEW_MARGIN = 80;
+    PAGE_CANVAS = "#0d1117";
+    PAGE_PANEL = "#161b22";
+    PAGE_BORDER = "#30363d";
+    PAGE_FG = "#c9d1d9";
+    PAGE_DIM = "#8b949e";
+    PAGE_ACCENT = "#58a6ff";
+    PAGE_AMBER = "#d29922";
+    CHIP_STROKE = "#999";
+    CHIP_LABEL = "#333";
+    PORT_FILL = "#d9d9d9";
+    CHIP_FILL = Object.freeze({
+      cron: "#a6bbcf",
+      label: "#d8bfd8",
+      comment: "#e7e7ae",
+      pull_request: "#c0deed",
+      skill: "#fdd0a2"
+    });
+    STATUS_COMPLETED = "#3fb950";
+    STATUS_FAILED = "#ff5f57";
+    STATUS_OTHER = "#6e7681";
+    BADGE_ORANGE = "#db6d28";
+    BADGE_GREEN = "#3fb950";
+    DANGER = "#f85149";
+    GROUP_FILL = "#E6E0F8";
+    WIRE_OBSERVED = "#999";
+    WIRE_CONFIG = "#6e7681";
+    WIRE_POTENTIAL = "#8b949e";
+    GLYPH = Object.freeze({
+      cron: "\u25F7",
+      label: "\u25C8",
+      comment: "\u275D",
+      pull_request: "\u21C4",
+      skill: "\u0192",
+      "skill-missing": "!",
+      "skill-unverified": "?",
+      injected: "+"
+    });
+    ORANGE_FLAGS = /* @__PURE__ */ new Set(["unread", "injected-ai-trigger", "pr-spend-loop-risk"]);
+    DANGLING_FLAGS = /* @__PURE__ */ new Set(["no-skill", "charset-invalid"]);
+    PAGE_CSS = `
+*{box-sizing:border-box;margin:0;padding:0}
+body{background:${PAGE_CANVAS};color:${PAGE_FG};font:14px/1.4 -apple-system,"Segoe UI",Roboto,Helvetica,Arial,sans-serif}
+#hdr{position:fixed;top:0;left:0;right:0;height:46px;display:flex;align-items:center;gap:12px;padding:0 14px;background:${PAGE_PANEL};border-bottom:1px solid ${PAGE_BORDER};z-index:3}
+#hdr h1{font-size:14px;font-weight:600}
+#stamp{color:${PAGE_DIM};font-size:12px}
+#stamp.stale{color:${PAGE_AMBER}}
+#hdr button,#hdr select{background:#21262d;color:${PAGE_FG};border:1px solid ${PAGE_BORDER};border-radius:6px;padding:3px 10px;font-size:12px}
+#banners{position:fixed;top:52px;left:10px;z-index:3;max-width:46%}
+.banner{background:#2d1517;border:1px solid ${DANGER};color:${DANGER};border-radius:6px;padding:6px 10px;margin-bottom:6px;font-size:12px}
+#wrap{position:relative;height:100vh;padding-top:46px}
+svg.canvas{display:block;width:100%;height:100%;cursor:grab;touch-action:none}
+#tip{position:absolute;display:none;max-width:340px;background:${PAGE_PANEL};border:1px solid ${PAGE_BORDER};border-radius:6px;padding:8px 10px;font-size:12px;color:${PAGE_FG};white-space:pre-line;pointer-events:none;z-index:4}
+#legend{position:fixed;top:56px;right:10px;width:256px;background:${PAGE_PANEL};border:1px solid ${PAGE_BORDER};border-radius:6px;padding:10px 12px;font-size:11px;color:${PAGE_DIM};z-index:2}
+#legend h2{font-size:11px;color:${PAGE_FG};margin:6px 0 4px}
+#legend .row{display:flex;align-items:center;gap:6px;margin:2px 0}
+#legend .caps{margin-top:8px;color:${PAGE_FG}}
+#legend .honesty{margin-top:4px;color:${PAGE_AMBER}}
+.gnode{cursor:pointer}
+.dim .gnode,.dim .gwire{opacity:.15}
+.dim .hi{opacity:1}
+`;
+    PAGE_JS = `
+(function () {
+  "use strict";
+  var svg = document.getElementById("graph");
+  var root = document.getElementById("root");
+  var tip = document.getElementById("tip");
+  var wrap = document.getElementById("wrap");
+  var stamp = document.getElementById("stamp");
+  var auto = document.getElementById("auto");
+  var reloadBtn = document.getElementById("reload");
+  var selected = null;
+  var autoTimer = null;
+  var hashTimer = null;
+
+  function nowClock() { return new Date().getTime(); }
+
+  function fmtAge(ms) {
+    var s = Math.max(0, Math.floor(ms / 1000));
+    if (s < 60) return s + "s";
+    var m = Math.floor(s / 60);
+    if (m < 60) return m + "m";
+    return Math.floor(m / 60) + "h";
+  }
+  function tickStamp() {
+    var age = nowClock() - GENERATED_AT;
+    stamp.textContent = "generated " + fmtAge(age) + " ago";
+    stamp.className = age > 600000 ? "stale" : "";
+  }
+  tickStamp();
+  setInterval(tickStamp, 1000);
+
+  if (reloadBtn) reloadBtn.addEventListener("click", function () { location.reload(); });
+  function applyAuto() {
+    if (autoTimer) { clearInterval(autoTimer); autoTimer = null; }
+    var s = auto ? parseInt(auto.value, 10) : 0;
+    if (s > 0) autoTimer = setInterval(function () { location.reload(); }, s * 1000);
+  }
+  if (auto) auto.addEventListener("change", function () { applyAuto(); writeHash(); });
+
+  if (!svg || !root) return;
+  var vb = svg.viewBox.baseVal;
+  var baseW = vb.width;
+
+  function writeHash() {
+    hashTimer = null;
+    var parts = ["vb=" + [vb.x, vb.y, vb.width, vb.height].map(function (v) { return Math.round(v * 10) / 10; }).join("_")];
+    if (selected) parts.push("sel=" + selected);
+    if (auto && auto.value !== "0") parts.push("ar=" + auto.value);
+    history.replaceState(null, "", "#" + parts.join("&"));
+  }
+  function scheduleHash() {
+    if (hashTimer) return;
+    hashTimer = setTimeout(writeHash, 300);
+  }
+  function readHash() {
+    var h = location.hash.replace(/^#/, "");
+    if (!h) return;
+    var kvs = h.split("&");
+    for (var i = 0; i < kvs.length; i++) {
+      var at = kvs[i].indexOf("=");
+      if (at < 0) continue;
+      var k = kvs[i].slice(0, at);
+      var v = kvs[i].slice(at + 1);
+      if (k === "vb") {
+        var n = v.split("_").map(parseFloat);
+        if (n.length === 4 && n.every(isFinite) && n[2] > 0 && n[3] > 0) {
+          vb.x = n[0]; vb.y = n[1]; vb.width = n[2]; vb.height = n[3];
+        }
+      } else if (k === "sel" && ownNode(v)) {
+        select(v);
+      } else if (k === "ar" && auto) {
+        auto.value = v === "5" || v === "30" ? v : "0";
+        applyAuto();
+      }
+    }
+  }
+
+  // With preserveAspectRatio meet, the browser scales UNIFORMLY (the smaller of the two ratios)
+  // and centres the letterboxed remainder; mapping each axis by its own ratio pans at the wrong
+  // speed and zooms beside the cursor whenever the element and viewBox aspects differ.
+  function view() {
+    var r = svg.getBoundingClientRect();
+    var s = Math.min(r.width / vb.width, r.height / vb.height);
+    return { r: r, s: s, ox: (r.width - vb.width * s) / 2, oy: (r.height - vb.height * s) / 2 };
+  }
+
+  var panning = null;
+  var suppressClick = false;
+  svg.addEventListener("pointerdown", function (e) {
+    if (e.button !== 0) return;
+    panning = { x: e.clientX, y: e.clientY, moved: 0 };
+    svg.setPointerCapture(e.pointerId);
+  });
+  svg.addEventListener("pointermove", function (e) {
+    if (panning) {
+      var v = view();
+      var dx = e.clientX - panning.x;
+      var dy = e.clientY - panning.y;
+      panning.moved += Math.abs(dx) + Math.abs(dy);
+      vb.x -= dx / v.s;
+      vb.y -= dy / v.s;
+      panning.x = e.clientX;
+      panning.y = e.clientY;
+      scheduleHash();
+    }
+    moveTip(e);
+  });
+  svg.addEventListener("pointerup", function (e) {
+    if (panning && svg.hasPointerCapture && svg.hasPointerCapture(e.pointerId)) svg.releasePointerCapture(e.pointerId);
+    // Pointer capture makes the click after a pan land on the svg, which would read as a
+    // background click and wipe the selection; a real drag therefore swallows that click.
+    suppressClick = panning !== null && panning.moved > 3;
+    panning = null;
+  });
+  svg.addEventListener("wheel", function (e) {
+    e.preventDefault();
+    var k = Math.exp(-e.deltaY * 0.0015);
+    var scale = baseW / (vb.width / k);
+    if (scale < 0.15 || scale > 4) return;
+    var v = view();
+    var px = vb.x + (e.clientX - v.r.left - v.ox) / v.s;
+    var py = vb.y + (e.clientY - v.r.top - v.oy) / v.s;
+    vb.x = px - (px - vb.x) / k;
+    vb.y = py - (py - vb.y) / k;
+    vb.width = vb.width / k;
+    vb.height = vb.height / k;
+    scheduleHash();
+  }, { passive: false });
+
+  // The ONLY indexed read of GRAPH.nodes: an id arriving from the hash (or a DOM id) could be a
+  // prototype-chain key like "constructor", which a bare truthy lookup would happily return and a
+  // later .nb dereference would throw on. A test pins this as the single raw read.
+  function ownNode(id) {
+    return Object.prototype.hasOwnProperty.call(GRAPH.nodes, id) ? GRAPH.nodes[id] : null;
+  }
+  function nodeAt(e) {
+    var el = e.target && e.target.closest ? e.target.closest(".gnode") : null;
+    return el && ownNode(el.id) ? el : null;
+  }
+  function moveTip(e) {
+    var el = nodeAt(e);
+    if (!el) { tip.style.display = "none"; return; }
+    tip.textContent = ownNode(el.id).tip;
+    tip.style.display = "block";
+    var wr = wrap.getBoundingClientRect();
+    tip.style.left = e.clientX - wr.left + 14 + "px";
+    tip.style.top = e.clientY - wr.top + 14 + "px";
+  }
+
+  function mark(id) {
+    var el = document.getElementById(id);
+    if (el) el.classList.add("hi");
+  }
+  function clearSel() {
+    selected = null;
+    root.classList.remove("dim");
+    var hi = root.querySelectorAll(".hi");
+    for (var i = 0; i < hi.length; i++) hi[i].classList.remove("hi");
+    scheduleHash();
+  }
+  function select(id) {
+    clearSel();
+    var g = ownNode(id);
+    if (!g) return;
+    selected = id;
+    root.classList.add("dim");
+    mark(id);
+    for (var i = 0; i < g.nb.length; i++) mark(g.nb[i]);
+    for (var j = 0; j < g.w.length; j++) mark(g.w[j]);
+    scheduleHash();
+  }
+  svg.addEventListener("click", function (e) {
+    if (suppressClick) { suppressClick = false; return; }
+    var el = nodeAt(e);
+    if (el) { if (selected === el.id) clearSel(); else select(el.id); }
+    else clearSel();
+  });
+  document.addEventListener("keydown", function (e) { if (e.key === "Escape") clearSel(); });
+
+  readHash();
+})();
+`;
+  }
+});
+
+// ../worker/src/open-browser.mjs
+import { spawn as nodeSpawn } from "node:child_process";
+function openBrowser(url, { spawn: spawn2 = nodeSpawn, platform = process.platform } = {}) {
+  const [cmd, args] = platform === "darwin" ? ["open", [url]] : platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn2(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+var init_open_browser = __esm({
+  "../worker/src/open-browser.mjs"() {
   }
 });
 
@@ -35315,7 +37088,7 @@ function setGlyphs(ascii) {
 function stripControls(s) {
   return String(s ?? "").replace(CONTROL_CHARS, "");
 }
-function clip(line, w) {
+function clip2(line, w) {
   const width = Math.max(0, Math.trunc(w) || 0);
   const clean = stripControls(line);
   if (clean.length <= width) return clean;
@@ -35325,13 +37098,13 @@ function clip(line, w) {
 }
 function pad(line, w) {
   const width = Math.max(0, Math.trunc(w) || 0);
-  return clip(line, width).padEnd(width);
+  return clip2(line, width).padEnd(width);
 }
 function box({ title = "", sections = [], footer, width = 40 } = {}) {
   const w = Math.max(MIN_WIDTH, Math.trunc(width) || MIN_WIDTH);
   const inner = w - 4;
   const lines = [];
-  const titleText = title ? ` ${clip(title, Math.max(0, inner - 2))} ` : "";
+  const titleText = title ? ` ${clip2(title, Math.max(0, inner - 2))} ` : "";
   const topFill = Math.max(0, w - 2 - 1 - titleText.length);
   lines.push(active.tl + active.h + titleText + active.h.repeat(topFill) + active.tr);
   const framed = (text) => `${active.v} ${pad(text, inner)} ${active.v}`;
@@ -35351,14 +37124,14 @@ function box({ title = "", sections = [], footer, width = 40 } = {}) {
 function meter(reserved, cap, width = 24, state = "ok") {
   const r = Number.isFinite(reserved) ? Math.max(0, Math.trunc(reserved)) : 0;
   if (!Number.isInteger(cap) || cap <= 0) {
-    return clip(`${r} / ? (cap unknown)`, width);
+    return clip2(`${r} / ? (cap unknown)`, width);
   }
   const tag = state === "soft-hold" ? " soft-hold" : state === "over" ? " over" : "";
   const label = ` ${r}/${cap}${tag}`;
   const barCells = Math.max(0, Math.trunc(width) - label.length - 2);
   const filled = Math.min(barCells, Math.round(Math.min(r, cap) / cap * barCells));
   const bar = `[${active.full.repeat(filled)}${active.empty.repeat(barCells - filled)}]`;
-  return clip(bar + label, width);
+  return clip2(bar + label, width);
 }
 function sparkline(values, width = 24, opts = {}) {
   const w = Math.max(0, Math.trunc(width) || 0);
@@ -35366,7 +37139,7 @@ function sparkline(values, width = 24, opts = {}) {
   const norm = (Array.isArray(values) ? values : []).map((v) => Number.isFinite(v) ? Math.max(0, v) : null);
   const finite = norm.filter((v) => v !== null);
   const ceiling = Number.isFinite(opts?.max) && opts.max > 0 ? opts.max : Math.max(0, ...finite);
-  if (finite.length === 0 || ceiling <= 0) return clip("no data", w);
+  if (finite.length === 0 || ceiling <= 0) return clip2("no data", w);
   let cells = norm;
   if (norm.length > w) {
     cells = [];
@@ -35544,9 +37317,9 @@ var init_sandbox_store = __esm({
 });
 
 // ../worker/src/sandbox.mjs
-import { execFile as execFile3, spawn } from "node:child_process";
+import { execFile as execFile4, spawn } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
-import { promisify as promisify3 } from "node:util";
+import { promisify as promisify4 } from "node:util";
 function sandboxContainerName(jobId) {
   return `${SANDBOX_NAME_PREFIX}${sanitizeJobId(jobId)}`;
 }
@@ -35591,14 +37364,14 @@ function launchSandbox({ args, spawnFn = spawn }) {
     child.on("close", (code) => resolve({ code }));
   });
 }
-var exec2, SANDBOX_NAME_PREFIX;
+var exec3, SANDBOX_NAME_PREFIX;
 var init_sandbox = __esm({
   "../worker/src/sandbox.mjs"() {
     init_config2();
     init_docker_run();
     init_run_history();
     init_sandbox_store();
-    exec2 = promisify3(execFile3);
+    exec3 = promisify4(execFile4);
     SANDBOX_NAME_PREFIX = "pi-sandbox-";
   }
 });
@@ -35624,8 +37397,8 @@ function renderRuns(runs) {
   const headers = RUN_COLUMNS.map((c) => c.header);
   const rows = list.map((r) => RUN_COLUMNS.map((c) => c.derive ? c.derive(r) : cell(r?.[c.key])));
   const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i].length)));
-  const fmt = (cells) => cells.map((v, i) => v.padEnd(widths[i])).join("  ").trimEnd();
-  return [fmt(headers), ...rows.map(fmt)].join("\n");
+  const fmt2 = (cells) => cells.map((v, i) => v.padEnd(widths[i])).join("  ").trimEnd();
+  return [fmt2(headers), ...rows.map(fmt2)].join("\n");
 }
 function renderBudget({ budget, settings: settings2 } = {}) {
   if (!budget || budget.unreachable) {
@@ -35802,8 +37575,8 @@ function renderWhatIf(result, { flow, target } = {}) {
 }
 function tableLines(headers, rows) {
   const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i].length)));
-  const fmt = (cells) => cells.map((v, i) => v.padEnd(widths[i])).join("  ").trimEnd();
-  return [fmt(headers), ...rows.map(fmt)];
+  const fmt2 = (cells) => cells.map((v, i) => v.padEnd(widths[i])).join("  ").trimEnd();
+  return [fmt2(headers), ...rows.map(fmt2)];
 }
 function renderSettingsView(settings2) {
   const path = settings2?.path ?? "(unknown path)";
@@ -35816,6 +37589,105 @@ function renderSettingsView(settings2) {
   }
   return out.join("\n");
 }
+function renderGraph(model) {
+  const m = model ?? {};
+  if (m.meta?.triggersMissing) return "Graph: no triggers file found";
+  if (typeof m.meta?.triggersInvalid === "string" && m.meta.triggersInvalid !== "") return `Graph: triggers file invalid: ${m.meta.triggersInvalid}`;
+  const nodes = Array.isArray(m.nodes) ? m.nodes : [];
+  const nodeById = new Map(nodes.map((n) => [n.id, n]));
+  const edges = Array.isArray(m.edges) ? m.edges : [];
+  const flagsByNode = /* @__PURE__ */ new Map();
+  for (const f of Array.isArray(m.flags) ? m.flags : []) {
+    if (!flagsByNode.has(f.nodeId)) flagsByNode.set(f.nodeId, []);
+    flagsByNode.get(f.nodeId).push(f.flag);
+  }
+  const out = ["Graph: triggers and flows"];
+  const triggerCount = nodes.filter((n) => n.kind === "trigger").length;
+  if (triggerCount === 0) out.push("", "no triggers configured");
+  for (const group of Array.isArray(m.folders) ? m.folders : []) {
+    if ((group.triggerIds?.length ?? 0) === 0 && (group.skillIds?.length ?? 0) === 0) continue;
+    out.push("", groupHeading(group));
+    for (const id of group.triggerIds ?? []) {
+      const t = nodeById.get(id);
+      if (t) out.push(`  ${graphTriggerLine(t, flagsByNode.get(id) ?? [])}`);
+    }
+    for (const id of group.skillIds ?? []) {
+      const s = nodeById.get(id);
+      if (!s || s.kind === "skill-unverified") continue;
+      out.push(`  ${graphSkillLine(s, flagsByNode.get(id) ?? [])}`);
+      for (const e of edges) {
+        if (e.from !== id || e.kind === "cron-rearm") continue;
+        const target = nodeById.get(e.to);
+        out.push(`    ${graphEdgeLine(e, target)}`);
+      }
+    }
+  }
+  const injected = nodes.filter((n) => n.kind === "injected");
+  if (injected.length > 0) {
+    out.push("", "injected skills (trigger-reachable, never AI-reachable):");
+    for (const n of injected) {
+      const marks = (flagsByNode.get(n.id) ?? []).includes("injected-ai-trigger") ? "  [ai-trigger: allow is a silent no-op here]" : "";
+      out.push(`  ${n.name} (${n.dir})${marks}`);
+    }
+  }
+  out.push("");
+  if ((m.meta?.unattributedRuns ?? 0) > 0) out.push(`${m.meta.unattributedRuns} runs unattributed (triggers file changed since they ran, or they predate attribution)`);
+  const refusals = Object.entries(m.meta?.chainRefusals ?? {});
+  if (refusals.length > 0) out.push(`chain refusals: ${refusals.map(([flow, n]) => `${flow} ${n}`).join(", ")}`);
+  const trunc = m.meta?.truncated ?? {};
+  if (trunc.folders) out.push("folder scan truncated (cap reached): unlisted folders are not empty, they are unscanned");
+  if (trunc.skills) out.push("skill enumeration truncated or partly unread");
+  if (trunc.edges) out.push("observed edges truncated (cap reached)");
+  if ((m.meta?.droppedObservedEdges ?? 0) > 0) out.push(`${m.meta.droppedObservedEdges} observed edges dropped (no unique readable folder to attach them to)`);
+  if ((m.meta?.injectedUnreachable ?? []).length > 0) out.push(`injected skills dir unreadable: ${m.meta.injectedUnreachable.join(", ")}`);
+  out.push("edges: -> configured, observed xN (from records), mention (potential; a mention is not a promise)");
+  out.push(capsLine(m.caps));
+  return out.join("\n");
+}
+function groupHeading(group) {
+  if (group.kind === "forge") {
+    const seen = Array.isArray(group.repos) && group.repos.length > 0 ? ` -- ran against: ${group.repos.join(", ")}` : "";
+    return `forge ${group.label}${seen} (skills unverifiable from the admin host)`;
+  }
+  const head = group.head ? `, HEAD ${String(group.head).slice(0, 7)}` : "";
+  const state = group.unreachable ? `, ${group.unreachable}` : "";
+  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";
+  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(" ")}` : ""}`;
+}
+function graphSkillLine(s, flags) {
+  const badges = [];
+  if (s.kind === "skill-missing") badges.push("[missing at HEAD]");
+  if (s.isSub) badges.push(`[sub-skill of ${s.group}: loadable, never a flow]`);
+  if (s.aiTrigger) badges.push("[chainable]");
+  for (const loop of Array.isArray(s.loops) ? s.loops : []) badges.push(`[loop: "${loop.hint}"]`);
+  if (flags.includes("orphan")) badges.push("[orphan: no trigger, no ai-trigger, no mention]");
+  if (flags.includes("ai-reachable-no-trigger")) badges.push("[AI-reachable, no trigger]");
+  if (flags.includes("unread")) badges.push("[SKILL.md unread: facts unknown]");
+  return `skill ${s.name}${badges.length ? `  ${badges.join(" ")}` : ""}`;
+}
+function graphEdgeLine(e, target) {
+  const name = target?.name ?? "(unknown)";
+  if (e.kind === "observed") return `-> ${name}  observed x${e.count}`;
+  if (e.kind === "potential") {
+    const fire = e.eligible ? "could fire" : "can never fire: target has no ai-trigger allow";
+    return `-> ${name}  mention (potential${e.strong ? ", strong" : ""}; ${fire})`;
+  }
+  return `-> ${name}  ${e.kind}`;
+}
+function capsLine(caps) {
+  const depth = caps?.chainDepthMax ?? "?";
+  const width = caps?.chainMaxPerJob ?? "?";
+  const window = caps?.windowDays ?? "?";
+  return `caps: chain depth <= ${depth}, <= ${width} per job, same folder only, window ${window}d`;
+}
 var SETTINGS_KEYS, BUDGET_WINDOWS, RUN_COLUMNS, COSTS_WINDOW_LABELS;
 var init_render = __esm({
   "src/render.mjs"() {
@@ -36035,8 +37907,8 @@ var init_style = __esm({
       inverse: (t) => t,
       strikethrough: (t) => t
     };
-    OVERLAY_GLYPHS = { tl: "\u250C", tr: "\u2510", bl: "\u2514", br: "\u2518", ml: "\u251C", mr: "\u2524", h: "\u2500", v: "\u2502", full: "\u2588", empty: "\u2591", ellipsis: "\u2026" };
-    OVERLAY_ASCII = { tl: "+", tr: "+", bl: "+", br: "+", ml: "+", mr: "+", h: "-", v: "|", full: "#", empty: ".", ellipsis: "..." };
+    OVERLAY_GLYPHS = { tl: "\u250C", tr: "\u2510", bl: "\u2514", br: "\u2518", ml: "\u251C", mr: "\u2524", h: "\u2500", v: "\u2502", full: "\u2588", empty: "\u2591", ellipsis: "\u2026", arrowRight: "\u2500\u25B6", foldOpen: "\u25BE", foldClosed: "\u25B8", rearm: "\u21BB" };
+    OVERLAY_ASCII = { tl: "+", tr: "+", bl: "+", br: "+", ml: "+", mr: "+", h: "-", v: "|", full: "#", empty: ".", ellipsis: "...", arrowRight: "->", foldOpen: "v", foldClosed: ">", rearm: "~" };
     COST_COLORS = {
       metered: "text",
       plan: "accent",
@@ -36112,6 +37984,30 @@ function createDashboardDeps(paths) {
       const fold = foldCosts({ records, subscriptions, pricing: pricing_exports, nowMs, piAiPin: piAiVersion() });
       return { fold, records, subscriptions };
     },
+    /**
+     * One GRAPH read (issue #54): triggers FRESH (OQ-008 -- a cached topology is a stale topology),
+     * one bounded record scan, the folder/injected enumerations, and the pure fold. Schedulers ride
+     * in from the caller's snapshot so this seam opens no second queue read. All fs/git access lives
+     * in the read-model functions this calls; this module still touches nothing itself.
+     */
+    fetchGraph({ schedulers } = {}) {
+      const nowMs = Date.now();
+      const triggersView = readTriggers({ triggersPath: paths.triggersPath });
+      const triggerList2 = Array.isArray(triggersView?.triggers) ? triggersView.triggers : [];
+      const records = scanRunRecords({ logsDir: paths.logsDir, sinceMs: nowMs - GRAPH_LIMITS.windowDays * 24 * 60 * 60 * 1e3, nowMs });
+      const recs = Array.isArray(records) ? records : [];
+      return buildGraphModel({
+        triggers: triggersView,
+        schedulers: Array.isArray(schedulers) ? schedulers : [],
+        ...collectGraphInputs({ triggers: triggerList2 }),
+        cronStats: cronRunStats({ records: recs, schedulerIds: triggerList2.filter((t) => t.type === "cron" && typeof t.id === "string").map((t) => t.id) }),
+        runJoin: joinRunsToTriggers({ records: recs, triggerCount: triggersView?.count, triggerTypes: Object.fromEntries(triggerList2.map((t) => [t.index, t.type])) }),
+        chainEdges: observedChainEdges({ records: recs }),
+        forgeRepos: forgeRepoTargets({ records: recs }),
+        caps: { chainDepthMax: paths.chainDepthMax, chainMaxPerJob: paths.chainMaxPerJob, windowDays: GRAPH_LIMITS.windowDays },
+        nowMs
+      });
+    },
     /** The priced-model catalog for the what-if `/` filter -- the façade stays behind this seam. */
     listPricedModels() {
       return listPricedModels();
@@ -36146,7 +38042,7 @@ function makeDashboard({
   intervalMs = REFRESH_MS,
   deps = createDashboardDeps(paths)
 } = {}) {
-  const styler = makeStyler(theme);
+  const styler = makeStyler(theme, { ascii: paths?.asciiGlyphs === true });
   let snapshot = null;
   let fetching = false;
   let disposed = false;
@@ -36156,6 +38052,7 @@ function makeDashboard({
   let detailRun = null;
   let detailSandbox = null;
   let detailTrigger = null;
+  let detailReturnTo = "LIST";
   let tailJobId = null;
   let tail = null;
   let tailTop = 0;
@@ -36169,6 +38066,9 @@ function makeDashboard({
   let costs = { data: null, windowKey: "mtd", fetchedAt: 0, table: "flow", whatIf: null };
   let costsSel = 0;
   let costsFetching = false;
+  let graph = { model: null, error: null, fetchedAt: 0, folded: /* @__PURE__ */ new Set() };
+  let graphSel = 0;
+  let graphFetching = false;
   const refresh = async () => {
     if (fetching || disposed) return;
     fetching = true;
@@ -36209,6 +38109,20 @@ function makeDashboard({
       tui?.requestRender?.();
     }
   };
+  const fetchGraphNow = async () => {
+    if (typeof deps?.fetchGraph !== "function" || graphFetching || disposed) return;
+    graphFetching = true;
+    try {
+      graph.model = await deps.fetchGraph({ schedulers: snapshot?.schedulers ?? [] });
+      graph.error = null;
+    } catch (err) {
+      graph.error = err?.message ?? String(err);
+    } finally {
+      graph.fetchedAt = Date.now();
+      graphFetching = false;
+      tui?.requestRender?.();
+    }
+  };
   const computeWhatIf = () => {
     const wi = costs.whatIf;
     if (!wi) return;
@@ -36249,6 +38163,9 @@ function makeDashboard({
       if (view === "COSTS" && costsSel > costsTableRows(costs).length - 1) {
         costsSel = Math.max(0, costsTableRows(costs).length - 1);
       }
+      if (view === "GRAPH" && graphSel > graphRows(graph.model, graph.folded).length - 1) {
+        graphSel = Math.max(0, graphRows(graph.model, graph.folded).length - 1);
+      }
       return renderPanel(snapshot, width, {
         view,
         selected,
@@ -36269,6 +38186,9 @@ function makeDashboard({
         costs,
         costsSel,
         costsAvailable: typeof deps?.fetchCosts === "function",
+        graph,
+        graphSel,
+        graphAvailable: typeof deps?.fetchGraph === "function",
         copiedNote,
         copyAvailable: typeof deps?.copyText === "function",
         // Height through the injected seam, read per frame (a resize changes it): null (seam absent, or
@@ -36338,7 +38258,7 @@ function makeDashboard({
           return;
         }
         if (matchesKey(data, "escape")) {
-          view = "LIST";
+          view = detailReturnTo;
           detailTrigger = null;
           tui?.requestRender?.();
           return;
@@ -36519,6 +38439,45 @@ function makeDashboard({
         }
         return;
       }
+      if (view === "GRAPH") {
+        if (matchesKey(data, "escape")) {
+          view = "LIST";
+          tui?.requestRender?.();
+          return;
+        }
+        if (matchesKey(data, "up") || matchesKey(data, "down")) {
+          const step = matchesKey(data, "up") ? -1 : 1;
+          graphSel = Math.min(Math.max(0, graphRows(graph.model, graph.folded).length - 1), Math.max(0, graphSel + step));
+          tui?.requestRender?.();
+          return;
+        }
+        if (data === "\r" || data === "\n") {
+          const row = graphRows(graph.model, graph.folded)[graphSel];
+          if (!row) return;
+          if (row.kind === "folder") {
+            if (graph.folded.has(row.key)) graph.folded.delete(row.key);
+            else graph.folded.add(row.key);
+            tui?.requestRender?.();
+            return;
+          }
+          if (row.kind === "gtrigger") {
+            const record = (snapshot?.triggers?.triggers ?? []).find((t) => t?.index === row.node.index);
+            if (!record) return;
+            detailTrigger = { record, index: row.node.index };
+            pendingDelete = false;
+            detailReturnTo = "GRAPH";
+            view = "TRIGGER_DETAIL";
+            tui?.requestRender?.();
+            return;
+          }
+          return;
+        }
+        if (data === "r" || data === "R") {
+          void fetchGraphNow();
+          return;
+        }
+        return;
+      }
       if (matchesKey(data, "escape") || data === "q" || data === "Q") {
         void dispose().finally(() => done(void 0));
         return;
@@ -36530,6 +38489,7 @@ function makeDashboard({
         if (row.kind === "trigger") {
           detailTrigger = { record: row.trigger, index: row.index };
           pendingDelete = false;
+          detailReturnTo = "LIST";
           view = "TRIGGER_DETAIL";
           tui?.requestRender?.();
         } else if (row.kind === "active") {
@@ -36563,6 +38523,13 @@ function makeDashboard({
         tui?.requestRender?.();
         return;
       }
+      if (data === "g" || data === "G") {
+        view = "GRAPH";
+        graphSel = 0;
+        void fetchGraphNow();
+        tui?.requestRender?.();
+        return;
+      }
       if (data === "	") {
         const rows = buildRows(snapshot, runSort);
         if (rows.length === 0) return;
@@ -36631,7 +38598,7 @@ function budgetMeters(budget, settings2, width) {
   return out;
 }
 function renderPanel(snapshot, width, state, styler) {
-  const { view, selected, detailRun, detailTrigger, tailJobId, tail, tailTop, tailFollow, tailAvailable, tailSearchInput, tailQuery, tailMatchLine, detailSandbox, sandboxAvailable, pendingDelete, runSort, costs, costsSel, costsAvailable, copiedNote, copyAvailable, terminalRows } = state;
+  const { view, selected, detailRun, detailTrigger, tailJobId, tail, tailTop, tailFollow, tailAvailable, tailSearchInput, tailQuery, tailMatchLine, detailSandbox, sandboxAvailable, pendingDelete, runSort, costs, costsSel, costsAvailable, graph, graphSel, graphAvailable, copiedNote, copyAvailable, terminalRows } = state;
   const framed = Number.isFinite(width) && Math.trunc(width) >= MIN_WIDTH2;
   const inner = Math.trunc(width) - 4;
   const title = "pi-dispatch";
@@ -36668,6 +38635,9 @@ function renderPanel(snapshot, width, state, styler) {
   if (view === "COSTS") {
     return renderCosts2({ costs, costsSel, costsAvailable, framed, width: Math.trunc(width), styler, availableRows: terminalRows });
   }
+  if (view === "GRAPH") {
+    return renderGraphView({ graph, graphSel, graphAvailable, framed, width: Math.trunc(width), styler });
+  }
   if (snapshot === null) {
     if (!framed) return [`${title} -- loading`, "", KEY_HINTS];
     return box({ title, sections: [{ lines: ["loading"] }], footer: KEY_HINTS, width });
@@ -37094,7 +39064,162 @@ function triggerDetailHints(inner, styler, pendingDelete = false) {
 }
 function keyHints(inner, styler) {
   const k = (key, label) => styler.fg("accent", key) + " " + styler.fg("dim", label);
-  const hints = [k("\u2191\u2193\u21B5", "open"), k("a", "add"), k("w", "pauses"), k("l", "logs"), k("c", "costs"), k("p", "pause"), k("r", "resume"), k("q", "quit")].join(styler.fg("dim", " \xB7 "));
+  const hints = [k("\u2191\u2193", "open"), k("a", "add"), k("w", "pauses"), k("l", "logs"), k("c", "costs"), k("g", "graph"), k("p/r", "pause"), k("q", "quit")].join(styler.fg("dim", " \xB7 "));
+  return fitLine(hints, inner, styler);
+}
+function graphRows(model, folded) {
+  if (!model) return [];
+  const nodeById = new Map((model.nodes ?? []).map((n) => [n.id, n]));
+  const flagsByNode = /* @__PURE__ */ new Map();
+  for (const f of model.flags ?? []) {
+    if (!flagsByNode.has(f.nodeId)) flagsByNode.set(f.nodeId, []);
+    flagsByNode.get(f.nodeId).push(f.flag);
+  }
+  const rows = [];
+  for (const group of model.folders ?? []) {
+    if ((group.triggerIds?.length ?? 0) === 0 && (group.skillIds?.length ?? 0) === 0) continue;
+    const isFolded = folded?.has?.(group.key) === true;
+    rows.push({ kind: "folder", key: group.key, group, folded: isFolded });
+    if (isFolded) continue;
+    for (const id of group.triggerIds ?? []) {
+      const node = nodeById.get(id);
+      if (node) rows.push({ kind: "gtrigger", node, flags: flagsByNode.get(id) ?? [] });
+    }
+    for (const id of group.skillIds ?? []) {
+      const node = nodeById.get(id);
+      if (!node || node.kind === "skill-unverified") continue;
+      rows.push({ kind: "gskill", node, flags: flagsByNode.get(id) ?? [] });
+      for (const e of model.edges ?? []) {
+        if (e.from !== id || e.kind === "cron-rearm") continue;
+        rows.push({ kind: "gedge", edge: e, target: nodeById.get(e.to) });
+      }
+    }
+  }
+  for (const n of model.nodes ?? []) {
+    if (n.kind === "injected") rows.push({ kind: "ginjected", node: n, flags: flagsByNode.get(n.id) ?? [] });
+  }
+  return rows;
+}
+function graphRowLine(row, cursor, inner, styler) {
+  const G = styler.glyphs;
+  const pre = cursor ? styler.fg("accent", "\u203A ") : "  ";
+  if (row.kind === "folder") {
+    const g = row.group;
+    const fold = styler.fg("accent", row.folded ? G.foldClosed : G.foldOpen);
+    const label = g.kind === "forge" ? `forge ${g.label}` : `folder ${g.path ?? g.label}`;
+    const seen = g.kind === "forge" && Array.isArray(g.repos) && g.repos.length > 0 ? styler.fg("dim", ` \xB7 ran against ${g.repos.join(", ")}`) : "";
+    const state = g.unreachable ? styler.fg("warning", ` \xB7 ${g.kind === "forge" ? "skills unverifiable from this host" : g.unreachable}`) : g.head ? styler.fg("dim", ` \xB7 HEAD ${String(g.head).slice(0, 7)}`) : "";
+    return fitLine(pre + fold + " " + styler.fg("accent", label) + seen + state, inner, styler);
+  }
+  if (row.kind === "gtrigger") {
+    const t = row.node;
+    const kind = styler.cell(t.onType, KIND_WIDTH, { color: KIND_COLOR[t.onType] ?? "text" });
+    const stats = t.runs > 0 ? `runs ${t.runs}${t.lastOutcome ? ` \xB7 last ${t.lastOutcome}` : ""}` : "no runs in window";
+    const statColor = t.lastOutcome === "completed" ? "success" : t.lastOutcome ? "warning" : "dim";
+    const badges = graphBadges(row.flags, styler);
+    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);
+    return joinEnds(left, right, inner, styler);
+  }
+  if (row.kind === "gskill") {
+    const s = row.node;
+    const missing = s.kind === "skill-missing";
+    const name = missing ? styler.fg("error", s.name) : s.name;
+    const marks = [];
+    if (missing) marks.push(styler.fg("error", "[missing at HEAD]"));
+    if (s.isSub) marks.push(styler.fg("dim", `[sub of ${s.group}]`));
+    if (s.aiTrigger) marks.push(styler.fg("success", "[chainable]"));
+    for (const loop of Array.isArray(s.loops) ? s.loops : []) marks.push(styler.fg("accent", `${G.rearm} "${loop.hint}"`));
+    const badges = graphBadges(row.flags, styler);
+    return fitLine(pre + styler.fg("dim", "skill ") + name + (marks.length ? " " + marks.join(" ") : "") + badges, inner, styler);
+  }
+  if (row.kind === "gedge") {
+    const e = row.edge;
+    const name = row.target?.name ?? "(unknown)";
+    const label = e.kind === "observed" ? styler.fg("accent", `observed x${e.count}`) : e.kind === "potential" ? styler.fg("dim", `mention (potential${e.strong ? ", strong" : ""}; ${e.eligible ? "could fire" : "can never fire"})`) : styler.fg("dim", e.kind);
+    return fitLine(pre + "  " + styler.fg("dim", `${G.bl} ${G.arrowRight} `) + name + "  " + label, inner, styler);
+  }
+  if (row.kind === "ginjected") {
+    const warn = row.flags.includes("injected-ai-trigger") ? " " + styler.fg("error", "[ai-trigger is a silent no-op here]") : "";
+    return fitLine(pre + styler.fg("dim", "injected ") + row.node.name + styler.fg("dim", ` (${row.node.dir})`) + warn, inner, styler);
+  }
+  return fitLine(pre, inner, styler);
+}
+function graphBadges(flags, styler) {
+  const parts = [];
+  for (const flag of flags ?? []) {
+    if (flag === "no-skill") parts.push(styler.fg("error", "[no-skill]"));
+    else if (flag === "charset-invalid") parts.push(styler.fg("error", "[invalid name]"));
+    else if (flag === "orphan") parts.push(styler.fg("warning", "[orphan]"));
+    else if (flag === "ai-reachable-no-trigger") parts.push(styler.fg("warning", "[AI-reachable, no trigger]"));
+    else if (flag === "unread") parts.push(styler.fg("warning", "[unread]"));
+    else if (flag === "pr-spend-loop-risk") parts.push(styler.fg("error", "[spend-loop risk]"));
+  }
+  return parts.length ? " " + parts.join(" ") : "";
+}
+function joinEnds(left, right, inner, styler) {
+  const rightLen = styler.visibleLen(right);
+  const leftMax = Math.max(0, inner - rightLen - 2);
+  const leftFit = styler.visibleLen(left) > leftMax ? styler.cell(styler.stripAnsi(left), leftMax) : left + " ".repeat(leftMax - styler.visibleLen(left));
+  return leftFit + "  " + right;
+}
+function renderGraphView({ graph, graphSel, graphAvailable, framed, width, styler }) {
+  const title = `pi-dispatch ${styler.glyphs.h}${styler.glyphs.h} GRAPH \xB7 triggers and flows`;
+  const inner = width - 4;
+  const model = graph?.model ?? null;
+  if (!framed) {
+    const plain = graph?.error ? [`graph unreachable (${graph.error})`] : model ? renderGraph(model).split("\n") : [graphAvailable ? "loading graph\u2026" : "graph unavailable in this build"];
+    return [styler.stripAnsi(title), "", ...plain, "", "\u2191\u2193 move \xB7 \u21B5 open/fold \xB7 r refresh \xB7 esc back"];
+  }
+  const lines = [];
+  if (graph?.error) {
+    lines.push(fitLine(styler.fg("error", `graph unreachable (${graph.error})`), inner, styler));
+  } else if (model === null) {
+    lines.push(fitLine(styler.fg("dim", graphAvailable ? "loading graph\u2026" : "graph unavailable in this build"), inner, styler));
+  } else if (model.meta?.triggersMissing) {
+    lines.push(fitLine(styler.fg("warning", "no triggers file found"), inner, styler));
+  } else if (typeof model.meta?.triggersInvalid === "string" && model.meta.triggersInvalid !== "") {
+    lines.push(fitLine(styler.fg("error", `triggers file invalid: ${model.meta.triggersInvalid}`), inner, styler));
+  } else {
+    const rows = graphRows(model, graph.folded);
+    if (rows.length === 0) {
+      lines.push(fitLine(styler.fg("dim", "no triggers configured"), inner, styler));
+    } else {
+      const top = Math.max(0, Math.min(graphSel - GRAPH_VIEWPORT + 1, rows.length - GRAPH_VIEWPORT));
+      if (top > 0) lines.push(fitLine(styler.fg("dim", `\u2026 ${top} above`), inner, styler));
+      rows.slice(top, top + GRAPH_VIEWPORT).forEach((row, i) => {
+        lines.push(graphRowLine(row, top + i === graphSel, inner, styler));
+      });
+      const below = rows.length - (top + GRAPH_VIEWPORT);
+      if (below > 0) lines.push(fitLine(styler.fg("dim", `\u2026 ${below} below`), inner, styler));
+    }
+    const counters = graphCounterLine(model, styler);
+    lines.push(RULE);
+    if (counters) lines.push(fitLine(counters, inner, styler));
+    lines.push(fitLine(styler.fg("dim", capsLineText2(model.caps)), inner, styler));
+  }
+  return frame(styler, { title, width, lines, footer: graphHints(inner, styler) });
+}
+function graphCounterLine(model, styler) {
+  const bits = [];
+  const meta = model?.meta ?? {};
+  if ((meta.unattributedRuns ?? 0) > 0) bits.push(`${meta.unattributedRuns} runs unattributed`);
+  const refused = Object.values(meta.chainRefusals ?? {}).reduce((a, n) => a + (Number(n) || 0), 0);
+  if (refused > 0) bits.push(`${refused} chain requests refused`);
+  const t = meta.truncated ?? {};
+  if (t.folders) bits.push("folders truncated");
+  if (t.skills) bits.push("skills truncated/unread");
+  if (t.edges) bits.push("edges truncated");
+  if ((meta.droppedObservedEdges ?? 0) > 0) bits.push(`${meta.droppedObservedEdges} observed edges dropped`);
+  if ((meta.injectedUnreachable ?? []).length > 0) bits.push(`${meta.injectedUnreachable.length} injected dirs unreadable`);
+  return bits.length ? styler.fg("warning", bits.join(" \xB7 ")) : null;
+}
+function capsLineText2(caps) {
+  return `caps: chain depth <= ${caps?.chainDepthMax ?? "?"} \xB7 <= ${caps?.chainMaxPerJob ?? "?"} per job \xB7 same folder only \xB7 window ${caps?.windowDays ?? "?"}d`;
+}
+function graphHints(inner, styler) {
+  const k = (key, label) => styler.fg("accent", key) + " " + styler.fg("dim", label);
+  const hints = [k("\u2191\u2193", "move"), k("\u21B5", "open/fold"), k("r", "refresh"), k("esc", "back")].join(styler.fg("dim", " \xB7 "));
   return fitLine(hints, inner, styler);
 }
 function costsWindowSinceMs(windowKey, nowMs) {
@@ -37359,7 +39484,7 @@ function countdownText(ms) {
   return h ? `resets ${h}` : "";
 }
 function buildRows(snapshot, runSort = "time") {
-  const triggers = (snapshot?.triggers?.triggers ?? []).map((t, i) => ({ kind: "trigger", trigger: t, index: i }));
+  const triggers = (snapshot?.triggers?.triggers ?? []).map((t, i) => ({ kind: "trigger", trigger: t, index: Number.isInteger(t?.index) ? t.index : i }));
   const active2 = snapshot?.activeJobId ? [{ kind: "active", jobId: snapshot.activeJobId }] : [];
   const runs = (Array.isArray(snapshot?.runs) ? snapshot.runs : []).map((record) => ({ kind: "run", record }));
   return [...triggers, ...active2, ...sortRuns(runs, runSort)];
@@ -37375,24 +39500,24 @@ function sortRuns(rows, runSort) {
   return sorted;
 }
 function renderRunList(rows, selected, w) {
-  if (!Array.isArray(rows) || rows.length === 0) return [clip("(no runs)", w)];
+  if (!Array.isArray(rows) || rows.length === 0) return [clip2("(no runs)", w)];
   const { top, count } = runsWindow(rows.length, selected);
   const out = [];
-  if (top > 0) out.push(clip(`^ ${top} more`, w));
+  if (top > 0) out.push(clip2(`^ ${top} more`, w));
   for (let i = top; i < top + count; i++) {
     const row = rows[i];
     const cursor = i === selected ? "\u203A" : " ";
     if (row.kind === "active") {
-      out.push(clip(`${cursor} * ACTIVE ${row.jobId} running`, w));
+      out.push(clip2(`${cursor} * ACTIVE ${row.jobId} running`, w));
       continue;
     }
     const run = row.record;
     const rep = run?.replica > 0 ? `r${run.replica}/${run.replicas ?? "?"} ` : "";
     const cells = [run?.jobId, run?.target, run?.flow, run?.outcome, run?.turns, run?.tokens?.total].map((f) => f === null || f === void 0 ? "-" : String(f)).join(" \xB7 ");
-    out.push(clip(`${cursor} ${rep}${cells}`, w));
+    out.push(clip2(`${cursor} ${rep}${cells}`, w));
   }
   const below = rows.length - top - count;
-  if (below > 0) out.push(clip(`v ${below} more`, w));
+  if (below > 0) out.push(clip2(`v ${below} more`, w));
   return out;
 }
 function tailMatches(lines, query) {
@@ -37433,14 +39558,14 @@ function renderLiveTail({ snapshot, framed, width, tailJobId, tail, tailTop, tai
     return [boxTitle, "", ...plain, "", footer];
   }
   const inner = Math.trunc(width) - 4;
-  const lines = [clip(`live ${tailJobId} -- ${len} line(s)`, inner)];
+  const lines = [clip2(`live ${tailJobId} -- ${len} line(s)`, inner)];
   for (let i = top; i < Math.min(top + TAIL_VIEWPORT, len); i++) {
-    const safe = clip(all[i], inner);
+    const safe = clip2(all[i], inner);
     lines.push(tailQuery !== null && i === tailMatchLine ? styler.fg("warning", safe) : safe);
   }
-  if (ended) lines.push(clip("(run ended -- Esc to go back)", inner));
+  if (ended) lines.push(clip2("(run ended -- Esc to go back)", inner));
   if (tailSearchInput) lines.push(styler.fg("accent", "/ ") + styler.lineInput(tailSearchInput, Math.max(1, inner - 2)));
-  return frame(styler, { title: boxTitle, width: Math.trunc(width), lines, footer: clip(footer, inner) });
+  return frame(styler, { title: boxTitle, width: Math.trunc(width), lines, footer: clip2(footer, inner) });
 }
 function renderRunDetail(record, inner, styler, allRuns = [], sandbox = null) {
   const r = record ?? {};
@@ -37536,7 +39661,7 @@ function runDetailHints(inner, styler, canOpen = false, canCopy = false, copiedN
   if (copiedNote) return fitLine(styler.fg("success", copiedNote) + styler.fg("dim", "  \xB7  ") + line, inner, styler);
   return fitLine(line, inner, styler);
 }
-var KEY_HINTS, RUNS_ON_DASHBOARD, RUNS_VIEWPORT, RUN_SORTS, REFRESH_MS, TAIL_LINES, TAIL_VIEWPORT, MIN_WIDTH2, DRILL_WIDTH, COSTS_WINDOWS, COSTS_STALE_MS, KIND_COLOR, KIND_WIDTH, FRAME_CHROME_ROWS, MONTHS;
+var KEY_HINTS, RUNS_ON_DASHBOARD, RUNS_VIEWPORT, RUN_SORTS, REFRESH_MS, TAIL_LINES, TAIL_VIEWPORT, MIN_WIDTH2, DRILL_WIDTH, COSTS_WINDOWS, COSTS_STALE_MS, GRAPH_VIEWPORT, KIND_COLOR, KIND_WIDTH, FRAME_CHROME_ROWS, MONTHS;
 var init_dashboard = __esm({
   "src/dashboard.ts"() {
     init_budget();
@@ -37547,6 +39672,7 @@ var init_dashboard = __esm({
     init_pricing();
     init_read_model();
     init_render();
+    init_graph_model();
     init_keys2();
     init_panel();
     init_style();
@@ -37562,6 +39688,7 @@ var init_dashboard = __esm({
     DRILL_WIDTH = 70;
     COSTS_WINDOWS = ["7d", "30d", "mtd"];
     COSTS_STALE_MS = 1e4;
+    GRAPH_VIEWPORT = 16;
     KIND_COLOR = { cron: "accent", label: "syntaxType", comment: "syntaxKeyword", pull_request: "syntaxFunction" };
     KIND_WIDTH = 13;
     FRAME_CHROME_ROWS = 4;
@@ -37589,7 +39716,7 @@ __export(setup_wizard_exports, {
   runtimeDirFor: () => runtimeDirFor
 });
 import * as nodeFs4 from "node:fs";
-import { execFileSync as execFileSync3, spawn as nodeSpawn } from "node:child_process";
+import { execFileSync as execFileSync3, spawn as nodeSpawn2 } from "node:child_process";
 import { homedir as homedir2 } from "node:os";
 import { join as join6 } from "node:path";
 function envIsSet(env, key) {
@@ -37624,7 +39751,7 @@ async function detectDeployment({
   }
   return { state: "none", detail: "no pointer, no env, no deployment files here, queue unreachable" };
 }
-async function runAttached(ctx, { title, argv0, args, cwd, env, shell, spawnFn = nodeSpawn }) {
+async function runAttached(ctx, { title, argv0, args, cwd, env, shell, spawnFn = nodeSpawn2 }) {
   if (ctx?.mode !== "tui" || typeof ctx?.ui?.custom !== "function") {
     return { code: null, error: new Error("needs the terminal UI") };
   }
@@ -38098,8 +40225,8 @@ var init_setup_wizard = __esm({
     init_deployment_pointer();
     init_read_model();
     init_index();
-    RUNTIME_VERSION = "0.2.0";
-    RECEIVER_VERSION = "0.2.0";
+    RUNTIME_VERSION = "0.3.0";
+    RECEIVER_VERSION = "0.2.1";
     RUNTIME_PKG = "@edgehero/pi-dispatch";
     RECEIVER_PKG = "@edgehero/pi-dispatch-receiver";
     NUDGE_MARKER_BASENAME = "pi-dispatch-setup.nudged";
@@ -38116,7 +40243,7 @@ var init_setup_wizard = __esm({
 
 // src/index.ts
 import { VERSION } from "@earendil-works/pi-coding-agent";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 import * as nodeFs5 from "node:fs";
 function computePiVersionAdvisory(version, supported) {
   if (version === supported || version === "0.0.0") return void 0;
@@ -38633,6 +40760,18 @@ ${renderBudget({ budget, settings: settings2 })}`);
       costsCommand(pi, paths, tokens, notify);
       return;
     }
+    case "graph": {
+      if (tokens[1] === "html") {
+        await graphHtmlCommand(paths, tokens, notify);
+        return;
+      }
+      if (tokens.length > 1) {
+        notify?.(GRAPH_USAGE, "warning");
+        return;
+      }
+      send(pi, renderGraph(await assembleGraph(paths)));
+      return;
+    }
     case "run": {
       const folder = tokens[1];
       const flow = tokens[2];
@@ -38709,6 +40848,63 @@ function assembleCosts(paths, window, flow) {
   });
   return { fold };
 }
+async function assembleGraph(paths) {
+  const nowMs = Date.now();
+  const triggers = readTriggers({ triggersPath: paths.triggersPath });
+  const triggerList2 = Array.isArray(triggers?.triggers) ? triggers.triggers : [];
+  const schedulers = await readSchedulers({ url: paths.valkeyUrl });
+  const records = scanRunRecords({ logsDir: paths.logsDir, sinceMs: nowMs - GRAPH_LIMITS.windowDays * 24 * 60 * 60 * 1e3, nowMs });
+  const recs = Array.isArray(records) ? records : [];
+  return buildGraphModel({
+    triggers,
+    schedulers: Array.isArray(schedulers) ? schedulers : [],
+    ...collectGraphInputs({ triggers: triggerList2 }),
+    cronStats: cronRunStats({ records: recs, schedulerIds: triggerList2.filter((t) => t.type === "cron" && typeof t.id === "string").map((t) => t.id) }),
+    runJoin: joinRunsToTriggers({ records: recs, triggerCount: triggers?.count, triggerTypes: Object.fromEntries(triggerList2.map((t) => [t.index, t.type])) }),
+    chainEdges: observedChainEdges({ records: recs }),
+    forgeRepos: forgeRepoTargets({ records: recs }),
+    caps: { chainDepthMax: paths.chainDepthMax, chainMaxPerJob: paths.chainMaxPerJob, windowDays: GRAPH_LIMITS.windowDays },
+    nowMs
+  });
+}
+function realGraphHtmlDeps() {
+  return { fs: nodeFs5, openBrowser, env: process.env, now: () => Date.now(), platform: process.platform };
+}
+function isHeadlessEnv(env, platform) {
+  if (env?.SSH_CONNECTION || env?.SSH_TTY) return "SSH session";
+  if (platform === "linux" && !env?.DISPLAY && !env?.WAYLAND_DISPLAY) return "no display";
+  return null;
+}
+async function graphHtmlCommand(paths, tokens, notify, deps = realGraphHtmlDeps()) {
+  const rest = tokens.slice(2);
+  const noOpen = rest.includes("--no-open");
+  const fullPaths = rest.includes("--full-paths");
+  if (rest.some((t) => t !== "--no-open" && t !== "--full-paths")) {
+    notify?.(GRAPH_USAGE, "warning");
+    return;
+  }
+  const model = await assembleGraph(paths);
+  const html = buildGraphHtml(model, { now: deps.now(), fullPaths });
+  const file = `${paths.graphDir}/graph.html`;
+  try {
+    deps.fs.mkdirSync(paths.graphDir, { recursive: true });
+    const tmp = `${file}.tmp`;
+    deps.fs.writeFileSync(tmp, html, { mode: 420 });
+    deps.fs.renameSync(tmp, file);
+  } catch (err) {
+    notify?.(`graph html: could not write ${file} (${err?.message ?? err})`, "error");
+    return;
+  }
+  const url = pathToFileURL(file).href;
+  notify?.(`graph written: ${url}`, "info");
+  if (noOpen) return;
+  const headless = isHeadlessEnv(deps.env, deps.platform);
+  if (headless) {
+    notify?.(`not opening a browser (${headless}): open the URL on this machine's desktop, or scp the file there`, "info");
+    return;
+  }
+  deps.openBrowser(url);
+}
 function costsCommand(pi, paths, tokens, notify) {
   if (tokens[1] === "whatif") {
     costsWhatIf(pi, paths, tokens, notify);
@@ -39148,6 +41344,11 @@ function completeArguments(prefix) {
     const items = ["7d", "30d", "mtd", "whatif"].filter((w) => w.startsWith(partial)).map((w) => ({ value: `costs ${w}`, label: w }));
     return items.length > 0 ? items : null;
   }
+  if (parts[0] === "graph" && parts.length === 2) {
+    const partial = parts[1];
+    const items = ["html"].filter((w) => w.startsWith(partial)).map((w) => ({ value: `graph ${w}`, label: w }));
+    return items.length > 0 ? items : null;
+  }
   if ((parts[0] === "set" || parts[0] === "unset") && parts.length === 2) {
     const partial = parts[1];
     const items = KNOWN_KEYS.filter((k) => k.startsWith(partial)).map((k) => ({
@@ -39158,11 +41359,14 @@ function completeArguments(prefix) {
   }
   return null;
 }
-var USED_API, SUPPORTED_PI_VERSION, piVersionAdvisory, piVersionCheckDone, runtimeSkewNoticed, CHANNEL, REBUILT_NOTICE, USAGE, KNOWN_SUBCOMMANDS, FORGE_PROMPT, PR_ACTION_VOCAB, COSTS_WINDOWS2, COSTS_USAGE, DAY_MS2, PRICING, VIEWPORT_LINES;
+var USED_API, SUPPORTED_PI_VERSION, piVersionAdvisory, piVersionCheckDone, runtimeSkewNoticed, CHANNEL, REBUILT_NOTICE, USAGE, KNOWN_SUBCOMMANDS, FORGE_PROMPT, PR_ACTION_VOCAB, COSTS_WINDOWS2, COSTS_USAGE, DAY_MS2, PRICING, GRAPH_USAGE, VIEWPORT_LINES;
 var init_index = __esm({
   "src/index.ts"() {
     init_build();
     init_read_model();
+    init_graph_model();
+    init_graph_html();
+    init_open_browser();
     init_deployment_pointer();
     init_costs();
     init_pricing();
@@ -39179,7 +41383,7 @@ var init_index = __esm({
     runtimeSkewNoticed = false;
     CHANNEL = "pi-dispatch-admin";
     REBUILT_NOTICE = (reason) => `replaced invalid settings file (${reason}) \u2014 other keys were lost`;
-    USAGE = "usage: /dispatch <status|pause|resume|run|runs|logs|budget|costs|triggers|settings|set|unset|setup>";
+    USAGE = "usage: /dispatch <status|pause|resume|run|runs|logs|budget|costs|graph|triggers|settings|set|unset|setup>";
     KNOWN_SUBCOMMANDS = [
       "status",
       "pause",
@@ -39189,6 +41393,7 @@ var init_index = __esm({
       "logs",
       "budget",
       "costs",
+      "graph",
       "triggers",
       "settings",
       "set",
@@ -39206,6 +41411,7 @@ var init_index = __esm({
     COSTS_USAGE = "usage: /dispatch costs [7d|30d|mtd] | /dispatch costs whatif <provider/model> --flow <flow>";
     DAY_MS2 = 24 * 60 * 60 * 1e3;
     PRICING = { listPricedModels, getPricedModel, isZeroRated, reprice, piAiVersion };
+    GRAPH_USAGE = "usage: /dispatch graph [html [--no-open] [--full-paths]]";
     VIEWPORT_LINES = 20;
   }
 });
@@ -39217,5 +41423,7 @@ export {
   buildTriggerEntry,
   computePiVersionAdvisory,
   admin as default,
-  handleDashboardAction
+  graphHtmlCommand,
+  handleDashboardAction,
+  isHeadlessEnv
 };