raidlock 0.1.0__py3-none-any.whl

raidlock/web/export.py

@@ -0,0 +1,153 @@
+from html import escape
+
+LANES = (
+    ("review", "Review"),
+    ("blocked", "Blocked"),
+    ("doing", "In progress"),
+    ("todo", "To do"),
+    ("done", "Done"),
+    ("cancelled", "Cancelled"),
+)
+STYLE = (
+    "body{font:14px/1.45 system-ui,sans-serif;margin:0 auto;max-width:1100px;padding:16px;"
+    "color:#1d1d24;background:#fafafa}"
+    "h1{font-size:22px}h2{font-size:16px;margin-top:24px}table{border-collapse:collapse;width:100%}"
+    "td,th{border-bottom:1px solid #ddd;padding:4px 6px;text-align:left;vertical-align:top;overflow-wrap:anywhere}"
+    ".m{color:#666;font-size:12px}.wrap{overflow-x:auto}"
+)
+
+
+def _usd(v):
+    return "-" if v is None else f"${float(v):.2f}"
+
+
+def _rows(items, cols):
+    head = "".join(f"<th>{escape(c)}</th>" for c, _ in cols)
+    body = "".join("<tr>" + "".join(f"<td>{escape(str(f(i)))}</td>" for _, f in cols) + "</tr>" for i in items)
+    return f'<div class="wrap"><table><thead><tr>{head}</tr></thead><tbody>{body}</tbody></table></div>'
+
+
+def _trust(agent):
+    inputs = agent.get("reputation_inputs") or {}
+    measured = any(v for k, v in inputs.items() if not k.endswith("_rate") and isinstance(v, (int, float)))
+    return agent.get("reputation") if measured and agent.get("reputation") is not None else ""
+
+
+def _billing(agent):
+    mode = agent.get("billing") or ""
+    return "" if mode == "unknown" else mode
+
+
+def _known(value):
+    return "not reported" if value in (None, "", "unknown") else value
+
+
+def _usage(p):
+    parts = []
+    ctx = p.get("context") or {}
+    if ctx.get("used_percent") is not None:
+        parts.append(f"context {ctx['used_percent']:g}%")
+    parts += [f"{w.get('window') or 'window'} {w.get('used_percent')}%" for w in p.get("windows") or []]
+    return "; ".join(parts)
+
+
+def render(payload, records):
+    ws = payload.get("workspace", "")
+    out = [
+        f'<!doctype html><html lang="en"><head><meta charset="utf-8">'
+        f'<meta name="viewport" content="width=device-width, initial-scale=1">'
+        f"<title>raidlock snapshot: {escape(ws)}</title><style>{STYLE}</style></head><body>",
+        f'<h1>{escape(ws)}</h1><p class="m">Snapshot taken {escape(payload.get("now", ""))}. '
+        f"Secrets and local paths are redacted.</p>",
+    ]
+    total = payload.get("treasury", {}).get("total", {})
+    out.append(
+        f"<p>Spend {_usd(total.get('usd'))} over {total.get('tokens', 0)} tokens in {total.get('runs', 0)} runs.</p>"
+    )
+    out.append("<h2>Agents</h2>")
+    out.append(
+        _rows(
+            sorted(payload.get("agents", {}).items()),
+            [
+                ("Agent", lambda a: a[0]),
+                ("Status", lambda a: a[1].get("label", "")),
+                ("Card", lambda a: a[1].get("card", "")),
+                ("Model", lambda a: " · ".join(x for x in (a[1].get("model"), a[1].get("runtime")) if x)),
+                ("Billing", lambda a: _billing(a[1])),
+                ("Trust", lambda a: _trust(a[1])),
+            ],
+        )
+    )
+    limits = [p for p in (payload.get("limits") or {}).get("providers", []) if _usage(p)]
+    if limits:
+        out.append("<h2>Provider usage</h2>")
+        out.append(
+            _rows(
+                limits,
+                [
+                    ("Provider", lambda p: p.get("provider", "")),
+                    ("Plan", lambda p: p.get("plan") or ""),
+                    ("Usage", _usage),
+                    ("Updated", lambda p: p.get("observed_at") or ""),
+                ],
+            )
+        )
+    cards = payload.get("cards", [])
+    for lane, label in LANES:
+        mine = [c for c in cards if c.get("lane") == lane]
+        if not mine:
+            continue
+        out.append(f"<h2>{escape(label)} ({len(mine)})</h2>")
+        out.append(
+            _rows(
+                mine,
+                [
+                    ("Card", lambda c: c["id"]),
+                    ("Title", lambda c: c.get("title", "")),
+                    ("Owner", lambda c: c.get("owner", "")),
+                    ("Team", lambda c: c.get("team", "")),
+                    ("Cost", lambda c: _usd((c.get("cost") or {}).get("usd"))),
+                ],
+            )
+        )
+    out.append("<h2>By provider and model</h2>")
+    out.append(
+        _rows(
+            payload.get("scorecard", []),
+            [
+                ("Provider", lambda g: _known(g["provider"])),
+                ("Model", lambda g: _known(g["label"])),
+                ("Done", lambda g: g["done"]),
+                ("Review pass", lambda g: "-" if g["pass_rate"] is None else f"{round(g['pass_rate'] * 100)}%"),
+                ("Cost", lambda g: _usd(g["usd"])),
+            ],
+        )
+    )
+    if payload.get("model_reputation"):
+        out.append("<h2>Model trust scores</h2>")
+        out.append(
+            _rows(
+                payload["model_reputation"],
+                [
+                    ("Workspace", lambda r: r["workspace"]),
+                    ("Model", lambda r: _known(r.get("label", r["key"]))),
+                    ("Score / 100", lambda r: r["score"]),
+                    ("Inputs", lambda r: r["inputs"]),
+                ],
+            )
+        )
+    out.append("<h2>Recent activity</h2>")
+    out.append(
+        _rows(
+            list(reversed(records)),
+            [
+                ("Time", lambda r: r["ts"]),
+                ("From", lambda r: r["from"]["agent"]),
+                ("Kind", lambda r: r["kind"]),
+                ("Card", lambda r: r["task"]),
+                ("Text", lambda r: r["text"][:500]),
+            ],
+        )
+    )
+    out.append("</body></html>")
+    return "".join(out)

raidlock/web/frames/view.css

@@ -0,0 +1,25 @@
+.frames{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,300px),1fr));gap:10px}
+.frame{position:relative;background:var(--panel);border:1px solid var(--edge);border-left:5px solid var(--agc,var(--edge));border-radius:12px;padding:8px 10px;min-width:0;display:flex;flex-direction:column;gap:6px}
+.frame.lvl-warning{border-color:var(--s-stalled)}
+.frame.lvl-critical{border-color:var(--blocked)}
+.fhead{display:flex;gap:8px;align-items:center;min-width:0}
+.fhead .av{flex:none;width:30px;height:30px;border-radius:50%;display:grid;place-items:center;background:var(--pill);border:1px solid var(--agc,var(--edge));font-size:14px}
+.fname{display:flex;flex-direction:column;min-width:0;overflow-wrap:anywhere;font-size:14px}
+.fname .cls{font-size:12px}
+.fwho{display:flex;flex-wrap:wrap;gap:4px 6px;align-items:center;min-width:0}
+.prole{flex:none;padding:1px 8px;border-radius:999px;border:1px solid var(--edge);border-left-width:4px;font-size:12px;font-weight:700;color:var(--ink);background:var(--pill)}
+.prole-tank{border-color:var(--todo)}
+.prole-healer{border-color:var(--done)}
+.prole-dps{border-color:var(--blocked)}
+.fbar{display:grid;grid-template-columns:minmax(0,7.5rem) minmax(0,1fr);gap:2px 8px;align-items:center;font-size:14px}
+.fbar .fl{color:var(--muted)}
+.fbar .fv{grid-column:1/-1;font-size:12px;color:var(--muted);overflow-wrap:anywhere}
+.fbar .track{height:12px;border-radius:6px;background:var(--pill);border:1px solid var(--edge);overflow:hidden}
+.fbar .track i{display:block;height:100%;transform-origin:left center}
+.fbar.hp .track i{background:var(--done)}
+.fbar.hp.lvl-warning .track i{background:var(--s-stalled)}
+.fbar.hp.lvl-critical .track i{background:var(--blocked)}
+.fbar.mp .track i{background:var(--todo)}
+.handoff{margin:0;font-size:14px;padding:6px 8px;border-radius:8px;border:1px solid var(--s-stalled)}
+.handoff.lvl-critical{border-color:var(--blocked)}
+.handoff-sum{font-size:14px;padding:6px 10px;border:1px solid var(--blocked);border-radius:8px;margin:6px 0 10px}

raidlock/web/frames/view.js

@@ -0,0 +1,63 @@
+"use strict";
+(function () {
+  const views = window.RaidlockViews = window.RaidlockViews || [];
+  const ROLES = {tank: ["Tank", "holds the most leases and the hardest quests"], healer: ["Healer", "reviews, verifies and lifts curses for others"],
+    dps: ["DPS", "closes the most quests"]};
+
+  function role(c, f, raid) {
+    const r = raid && ROLES[f.party];
+    return r ? c.h("span", {class: `prole prole-${f.party}`, title: `${r[0]}: ${r[1]}`}, c.h("span", {class: "sr-only", text: "Party role: "}), r[0]) : null;
+  }
+
+  function bar(c, kind, pct, label, valuetext, level) {
+    const fill = c.h("i");
+    fill.classList.add("width-" + Math.round(Math.max(0, Math.min(100, pct || 0))));
+    return c.h("div", {class: `fbar ${kind} lvl-${level || "ok"}`},
+      c.h("span", {class: "fl", text: label}),
+      c.h("div", {class: "track", role: "meter", "aria-label": label, "aria-valuemin": "0", "aria-valuemax": "100",
+        "aria-valuenow": String(Math.round(Math.max(0, Math.min(100, pct || 0)))), "aria-valuetext": valuetext}, fill),
+      c.h("span", {class: "fv", text: valuetext}));
+  }
+
+  function frame(c, f, d, raid) {
+    const ctx = f.context, burn = f.burn;
+    const pct = ctx.pct;
+    const pctText = pct == null ? "not measured" : pct > 100 ? "over 100%" : `${Math.round(pct)}%`;
+    const tags = [];
+    if (ctx.source === "estimate") tags.push("estimate");
+    if (ctx.window_source !== "pricing") tags.push("assumed window");
+    const ctxText = `${pctText} of ${c.ktok(ctx.window)}${tags.length ? " (" + tags.join(", ") + ")" : ""}`;
+    const rate = burn.tokens_per_hour ? `${c.ktok(burn.tokens_per_hour)} tok/h · ${c.usd(burn.usd_per_hour)}/h` : "no timed runs yet";
+    const warn = f.handoff ? c.h("p", {class: `handoff lvl-${ctx.level}`, role: "status"},
+      c.h("b", {text: ctx.level === "critical" ? "Hand off now: " : "Hand off soon: "}),
+      `context is ${pctText} full. Write a handback note and start a fresh session.`) : null;
+    return c.h("div", {class: `frame ${c.agentClass(f.agent)} lvl-${ctx.level}`, "data-agent": f.agent},
+      c.h("div", {class: "fhead"}, c.h("span", {class: "av", "aria-hidden": "true", text: c.avatar(f.agent)}),
+        c.h("div", {class: "fname"}, c.h("span", {class: "fwho"}, c.h("b", {text: f.agent}), role(c, f, raid)),
+          c.h("span", {class: "cls", text: [c.modelName(f.model), f.status, f.card].filter(Boolean).join(" · ")}))),
+      bar(c, "hp", pct, "Context", ctxText, ctx.level),
+      bar(c, "mp", 100 * (burn.share || 0), "Burn rate", rate, "ok"),
+      ctx.source === "estimate" ? c.h("p", {class: "note-sm", text: "No recorded run yet: estimated from the transcript and card brief at about 4 characters per token."}) : null,
+      warn);
+  }
+
+  views.push({
+    id: "frames",
+    endpoint: "frames",
+    label: {raid: "Raid frames", plain: "Context"},
+    render(c, d, pane) {
+      const raid = c.theme === "raid";
+      const all = (d.agents || []).slice().sort((a, b) => (b.handoff - a.handoff) || ((b.context.pct || 0) - (a.context.pct || 0)) || a.agent.localeCompare(b.agent));
+      const list = all.filter(f => f.card || (f.status && f.status !== "idle") || f.handoff);
+      const idle = all.filter(f => !list.includes(f));
+      c.setKids(pane, [
+        c.h("div", {class: "view-head"}, c.h("h2", null, c.raid ? "Raid frames" : "Context and burn rate", c.raid && c.raidSub ? c.raidSub("Context and burn rate") : null),
+          c.h("p", {class: "cls", text: `Context fill uses the prompt tokens of each agent's newest recorded run; burn rate is tokens per hour of run time. Warnings at ${d.warn_pct}% and ${d.critical_pct}%.`})),
+        (d.handoffs || []).length ? c.h("p", {class: "handoff-sum", role: "status", text: `${d.handoffs.length} ${d.handoffs.length === 1 ? "agent is" : "agents are"} near the context limit: ${d.handoffs.join(", ")}`}) : null,
+        list.length ? c.h("div", {class: "frames"}, list.map(f => frame(c, f, d, raid))) : c.h("p", {class: "empty", text: all.length ? "No agent holds a card right now." : "No agents joined yet. A worker joins with raid up --join."}),
+        idle.length ? c.h("details", {class: "sub-fold"}, c.h("summary", {text: `${idle.length} idle ${idle.length === 1 ? "agent" : "agents"}`}),
+          c.h("div", {class: "frames"}, idle.map(f => frame(c, f, d, raid)))) : null],
+        JSON.stringify([d, c.theme]));
+    }
+  });
+})();

raidlock/web/graph/__init__.py

@@ -0,0 +1,142 @@
+"""Card dependency graph and a lock-contention heatmap (lock path by day)."""
+
+from raidlock.core.errors import RaidlockError
+from raidlock.core.paths import overlaps
+
+from ..raidmap import lock_events, territory
+from ..replay import data_of, text_of
+
+DAYS = 14
+MAX_ROWS = 40
+
+
+MAX_NODES = 5000
+MAX_EDGES = 20000
+
+
+class GraphTooLarge(RaidlockError):
+    pass
+
+
+def layers(cards):
+    if len(cards) > MAX_NODES or sum(len(c.get("depends", [])) for c in cards) > MAX_EDGES:
+        raise GraphTooLarge("graph too large")
+    ids = {c["id"] for c in cards}
+    deps = {c["id"]: [d for d in c.get("depends", []) if d in ids] for c in cards}
+    depth, cycles = {}, []
+    active = set()
+    for root in sorted(ids):
+        if root in depth:
+            continue
+        stack = [(root, iter(deps[root]))]
+        active.add(root)
+        while stack:
+            cid, children = stack[-1]
+            child = next(children, None)
+            if child is None:
+                depth[cid] = 1 + max((depth.get(d, -1) for d in deps[cid]), default=-1)
+                active.remove(cid)
+                stack.pop()
+            elif child in active:
+                trail = [node for node, _ in stack]
+                cycles.append(trail[trail.index(child) :])
+            elif child not in depth:
+                active.add(child)
+                stack.append((child, iter(deps[child])))
+    return depth, cycles
+
+
+def dependency_graph(cards):
+    depth, cycles = layers(cards)
+    ids = {c["id"] for c in cards}
+    rows = {}
+    nodes = []
+    order = ("doing", "review", "blocked", "todo", "done", "cancelled")
+
+    def sort_key(c):
+        lane = c.get("lane", "todo")
+        return depth[c["id"]], order.index(lane) if lane in order else len(order), c["id"]
+
+    for c in sorted(cards, key=sort_key):
+        d = depth[c["id"]]
+        rows[d] = rows.get(d, -1) + 1
+        nodes.append(
+            {
+                "id": c["id"],
+                "title": c.get("title", ""),
+                "lane": c.get("lane", ""),
+                "owner": c.get("owner", ""),
+                "team": c.get("team", ""),
+                "repos": c.get("repos") or sorted({p.split("/")[0] for p in c.get("locks", [])}),
+                "depth": d,
+                "row": rows[d],
+            }
+        )
+    edges = []
+    for c in cards:
+        for dep in c.get("depends", []):
+            edges.append({"from": dep, "to": c["id"], "missing": dep not in ids})
+    return {"nodes": nodes, "edges": edges, "cycles": cycles, "columns": 1 + max(depth.values(), default=-1)}
+
+
+def heatmap(board, cards):
+    by_id = {c["id"]: c for c in cards}
+    hits = {}
+    takeovers = []
+    for r in board.transcript.read(kind="status", limit=5000):
+        if "taken over from" in text_of(r) and data_of(r).get("a2a_state") == "working":
+            takeovers.append({"ts": r.get("ts", ""), "paths": by_id.get(r.get("taskId", ""), {}).get("locks", [])})
+    events = [{"ts": e["ts"], "paths": e["paths"], "event": e["event"]} for e in lock_events(board)]
+    events += [{"ts": t["ts"], "paths": t["paths"], "event": "takeover"} for t in takeovers]
+    locked = {p for c in cards for p in c.get("locks", [])}
+    loose = {p for e in events for p in e["paths"] if not any(overlaps(p, q) for q in locked)}
+    paths = sorted(locked | loose)
+    days = sorted({e["ts"][:10] for e in events if e["ts"]})[-DAYS:]
+    for e in events:
+        day = e["ts"][:10]
+        if day not in days:
+            continue
+        for p in paths:
+            if any(overlaps(p, q) for q in e["paths"]):
+                row = hits.setdefault(p, {})
+                cell = row.setdefault(day, {"lock_denied": 0, "lock_violation": 0, "takeover": 0})
+                cell[e["event"]] += 1
+    waiting = {e["path"]: len(e["waiting"]) for repo in territory(board)["repos"] for e in repo["paths"]}
+    rows = []
+    for p in paths:
+        cells = [hits.get(p, {}).get(d, {"lock_denied": 0, "lock_violation": 0, "takeover": 0}) for d in days]
+        total = sum(sum(c.values()) for c in cells)
+        if not total and not waiting.get(p):
+            continue
+        rows.append({"path": p, "cells": cells, "total": total, "waiting": waiting.get(p, 0)})
+    rows.sort(key=lambda r: (-(r["total"] + r["waiting"]), r["path"]))
+    peak = max([sum(c.values()) for r in rows for c in r["cells"]] + [0])
+    return {"days": days, "rows": rows[:MAX_ROWS], "peak": peak, "paths": len(paths)}
+
+
+def build(board):
+    cards = board.cards()
+    return {**dependency_graph(cards), "heat": heatmap(board, cards)}
+
+
+def payload(board, query):
+    return build(board)
+
+
+def _handle(ctx, args):
+    result = build(ctx.board)
+    lines = [f"{len(result['nodes'])} cards, {len(result['edges'])} dependencies"]
+    for e in result["edges"]:
+        lines.append(f"  {e['from']} -> {e['to']}" + (" (missing)" if e["missing"] else ""))
+    for c in result["cycles"]:
+        lines.append("  cycle: " + " -> ".join(c))
+    heat = result["heat"]
+    if heat["rows"]:
+        lines.append("Contention:")
+        for r in heat["rows"]:
+            lines.append(f"  {r['path']}: {r['total']} events, {r['waiting']} waiting")
+    return result, "\n".join(lines)
+
+
+def register_cli(add_command):
+    add_command("graph", "card dependency graph and lock-contention heatmap", None, _handle)

raidlock/web/graph/view.css

@@ -0,0 +1,33 @@
+#viewPane>h3{font-size:14px;color:var(--accent);margin:14px 0 4px}
+.dep-svg .edge{fill:none;stroke:var(--muted);stroke-width:1.6}
+.dep-svg .arrow{fill:var(--muted)}
+.dep-svg .gnode rect{fill:var(--card1);stroke:var(--lc,var(--edge));stroke-width:2}
+.dep-svg .gid{fill:var(--ink);font-size:14px;font-weight:bold;font-family:var(--font)}
+.dep-svg .gsub{fill:var(--muted);font-size:12px;font-family:var(--font)}
+.gnode.lane-todo,.lane-sw.lane-todo{--lc:var(--todo)}.gnode.lane-doing,.lane-sw.lane-doing{--lc:var(--doing)}.gnode.lane-review,.lane-sw.lane-review{--lc:var(--review)}
+.gnode.lane-blocked,.lane-sw.lane-blocked{--lc:var(--blocked)}.gnode.lane-done,.lane-sw.lane-done{--lc:var(--done)}
+#viewPane .sw.lane-sw{background:var(--lc)}
+.heat-svg .hday,.heat-svg .hpath{fill:var(--muted);font-size:12px;font-family:var(--font)}
+.heat-svg .hpath{fill:var(--ink)}
+.heat-svg .hnum{fill:var(--ink);font-size:14px;font-weight:bold;font-family:var(--font);pointer-events:none}
+.heat-svg .hcell{stroke:var(--edge);fill:var(--card2)}
+.heat-svg .heat-1{fill:color-mix(in srgb,var(--blocked) 25%,var(--card2))}
+.heat-svg .heat-2{fill:color-mix(in srgb,var(--blocked) 45%,var(--card2))}
+.heat-svg .heat-3{fill:color-mix(in srgb,var(--blocked) 65%,var(--card2))}
+.heat-svg .heat-4{fill:color-mix(in srgb,var(--blocked) 85%,var(--card2))}
+.heat-svg .wait-1{fill:color-mix(in srgb,var(--s-stalled) 30%,var(--card2))}
+.heat-svg .wait-2{fill:color-mix(in srgb,var(--s-stalled) 55%,var(--card2))}
+.heat-svg .wait-3{fill:color-mix(in srgb,var(--s-stalled) 80%,var(--card2))}
+.as-text{margin-top:8px;font-size:14px}
+.as-text summary{cursor:pointer;color:var(--accent)}
+.as-text .warn{color:var(--blocked)}
+
+#viewPane .scrollbox{box-sizing:border-box;width:100%;min-width:0;max-width:100%}
+#viewPane .dep-scroll{max-height:70vh;overflow:auto;overscroll-behavior:contain}
+.dep-svg .gtitle{fill:var(--ink);font-size:14px;font-family:var(--font)}
+.dep-svg .gnode{cursor:pointer;text-decoration:none}
+.dep-svg .gnode:focus rect{stroke:var(--accent);stroke-width:4}
+.dep-svg .lane-missing rect,.dep-svg .missing{stroke-dasharray:5 3}
+.dep-svg .lane-cancelled rect{stroke:var(--muted)}
+#viewPane .as-text{overflow-wrap:anywhere}
+@media(prefers-reduced-motion:reduce){.dep-svg *{animation:none!important;transition:none!important;scroll-behavior:auto!important}}

raidlock/web/graph/view.js

@@ -0,0 +1,136 @@
+"use strict";
+(function () {
+  const views = window.RaidlockViews = window.RaidlockViews || [];
+  const NW = 224, NH = 66, CG = 56, RG = 12, PAD = 12, LW = 230, CELL = 36, HEAD = 34;
+
+  function clip(t, n) { t = String(t || ""); return t.length > n ? t.slice(0, n - 1) + "…" : t; }
+
+  function depGraph(c, d) {
+    const nodes = [...(d.nodes || [])];
+    if (!nodes.length) return c.h("p", {class: "empty", text: "No cards yet. Add a card to see its dependencies."});
+    const known = new Set(nodes.map(n => n.id));
+    for (const e of d.edges || []) for (const id of [e.from, e.to]) {
+      if (!known.has(id)) {
+        known.add(id);
+        nodes.push({id, title: "Missing card", lane: "missing", depth: 0, missing: true});
+      }
+    }
+    const linked = new Set([...(d.edges || []).flatMap(e => [e.from, e.to]), ...(d.cycles || []).flat()]);
+    const drawn = nodes.filter(n => linked.has(n.id));
+    const loose = nodes.length - drawn.length;
+    const looseNote = loose ? c.h("p", {class: "cls", text: `${loose} ${loose === 1 ? "card has" : "cards have"} no dependencies; they are listed under Dependencies as text.`}) : null;
+    if (!drawn.length) return c.h("div", null, c.h("p", {class: "empty", text: c.raid ? "No quest chains yet. Link quests with raid edit <card> --depends <other>." : "No dependencies between cards yet. Link cards with raid edit <card> --depends <other>."}), looseNote);
+    const at = new Map(), rowAt = {};
+    let rows = 0;
+    for (const n of drawn) {
+      const col = Math.max(0, n.depth || 0), row = rowAt[col] = (rowAt[col] ?? -1) + 1;
+      rows = Math.max(rows, row + 1);
+      at.set(n.id, [PAD + col * (NW + CG), PAD + row * (NH + RG)]);
+    }
+    const width = PAD * 2 + Math.max(...drawn.map(n => Math.max(0, n.depth || 0))) * (NW + CG) + NW + CG;
+    const height = PAD * 2 + rows * (NH + RG);
+    const s = c.svg;
+    const defs = s("defs", null, s("marker", {id: "rlArrow", viewBox: "0 0 8 8", refX: "8", refY: "4", markerWidth: "8", markerHeight: "8", orient: "auto"},
+      s("path", {d: "M0,0 L8,4 L0,8 z", class: "arrow"})));
+    const edges = (d.edges || []).map(e => {
+      const [x1, y1] = at.get(e.from), [x2, y2] = at.get(e.to);
+      const start = x1 + NW, end = x2 > x1 ? x2 : x2 + NW;
+      const track = start + CG / 2;
+      const path = e.from === e.to
+        ? `M${start},${y1 + 18} h20 v30 h-20`
+        : `M${start},${y1 + NH / 2} H${track} V${y2 + NH / 2} H${end}`;
+      return s("path", {class: `edge${e.missing ? " missing" : ""}`, "data-from": e.from, "data-to": e.to, d: path, "marker-end": "url(#rlArrow)"},
+        s("title", {text: `${e.from} → ${e.to}${e.missing ? " (missing card)" : ""}`}));
+    });
+    const boxes = drawn.map(n => {
+      const [x, y] = at.get(n.id);
+      const label = `${n.id}: ${n.title} (${n.lane}${n.owner ? ", " + n.owner : ""})`;
+      const box = s(n.missing ? "g" : "a", {class: `gnode lane-${n.lane}`, "data-id": n.id,
+        "data-card": n.missing ? null : n.id, href: n.missing ? null : `#card-${encodeURIComponent(n.id)}`,
+        tabindex: n.missing ? null : "0", "aria-label": label, transform: `translate(${x},${y})`},
+        s("title", {text: label}),
+        s("rect", {width: NW, height: NH, rx: "8"}),
+        s("text", {x: "10", y: "18", class: "gid", text: clip(n.id, 27)}),
+        s("text", {x: "10", y: "37", class: "gtitle", text: clip(n.title, 30)}),
+        s("text", {x: "10", y: "55", class: "gsub", text: clip(`${n.lane}${n.owner ? " · " + n.owner : ""}`, 30)}));
+      if (!n.missing) box.addEventListener("keydown", e => {
+        if (e.key === "Enter") { e.preventDefault(); box.dispatchEvent(new MouseEvent("click", {bubbles: true, cancelable: true})); }
+      });
+      return box;
+    });
+    return c.h("div", null, looseNote, c.h("div", {class: "scrollbox dep-scroll", tabindex: "0", role: "region", "aria-label": "Dependency graph, scrollable"},
+      s("svg", {width, height, viewBox: `0 0 ${width} ${height}`, role: "group", "aria-label": "Dependencies: arrows point to waiting cards", class: "dep-svg"}, defs, edges, boxes)));
+  }
+
+  function heat(c, d) {
+    const hm = d.heat || {};
+    const rows = hm.rows || [], days = hm.days || [];
+    if (!rows.length) return c.h("p", {class: "empty", text: "No contention recorded: no lock denials, write violations, takeovers or waiting cards."});
+    const s = c.svg;
+    const cols = days.length + 1;
+    const width = LW + cols * CELL + PAD, height = HEAD + rows.length * CELL + PAD;
+    const peak = Math.max(1, hm.peak || 0);
+    const kids = [];
+    days.forEach((day, i) => kids.push(s("text", {class: "hday", x: LW + i * CELL + CELL / 2, y: HEAD - 10, "text-anchor": "middle", text: day.slice(5)})));
+    kids.push(s("text", {class: "hday", x: LW + days.length * CELL + CELL / 2, y: HEAD - 10, "text-anchor": "middle", text: "wait"}));
+    rows.forEach((r, j) => {
+      const y = HEAD + j * CELL;
+      kids.push(s("text", {class: "hpath", x: LW - 8, y: y + CELL / 2 + 4, "text-anchor": "end", text: clip(r.path, 30)}, s("title", {text: r.path})));
+      r.cells.forEach((cell, i) => {
+        const n = cell.lock_denied + cell.lock_violation + cell.takeover;
+        const lvl = n ? Math.min(4, 1 + Math.floor(3 * n / peak)) : 0;
+        kids.push(s("rect", {class: `hcell heat-${lvl}`, x: LW + i * CELL + 2, y: y + 2, width: CELL - 4, height: CELL - 4, rx: "4", "data-path": r.path, "data-day": days[i]},
+          s("title", {text: `${r.path} on ${days[i]}: ${cell.lock_denied} denied, ${cell.lock_violation} write violations, ${cell.takeover} takeovers`})));
+        if (n) kids.push(s("text", {class: "hnum", x: LW + i * CELL + CELL / 2, y: y + CELL / 2 + 4, "text-anchor": "middle", text: String(n)}));
+      });
+      const w = r.waiting;
+      kids.push(s("rect", {class: `hcell wait-${w ? Math.min(3, w) : 0}`, x: LW + days.length * CELL + 2, y: y + 2, width: CELL - 4, height: CELL - 4, rx: "4"},
+        s("title", {text: `${r.path}: ${w} cards waiting now`})));
+      if (w) kids.push(s("text", {class: "hnum", x: LW + days.length * CELL + CELL / 2, y: y + CELL / 2 + 4, "text-anchor": "middle", text: String(w)}));
+    });
+    return c.h("div", {class: "scrollbox", tabindex: "0", role: "region", "aria-label": "Lock contention heatmap, scrollable"},
+      s("svg", {width, height, viewBox: `0 0 ${width} ${height}`, role: "img", class: "heat-svg",
+        "aria-label": `Lock contention by path and day: ${rows.length} paths, busiest ${rows[0].path}`}, kids));
+  }
+
+  function asText(c, d) {
+    const titles = Object.fromEntries((d.nodes || []).map(n => [n.id, n.title]));
+    const name = id => titles[id] ? `${id}: ${titles[id]}` : `${id}: Missing card`;
+    const items = (d.edges || []).map(e => c.h("li", {text: `${name(e.from)} → ${name(e.to)}${e.missing ? " (missing card)" : ""}`}));
+    for (const n of d.nodes || []) if (!(d.edges || []).some(e => e.from === n.id || e.to === n.id)) items.push(c.h("li", {text: `${name(n.id)} (no dependencies)`}));
+    for (const cy of d.cycles || []) items.push(c.h("li", {class: "warn", text: `cycle: ${cy.join(" → ")}`}));
+    return c.h("details", {class: "as-text"}, c.h("summary", {text: "Dependencies as text"}), items.length ? c.h("ul", null, items) : c.h("p", {class: "cls", text: "No dependencies."}));
+  }
+
+  views.push({
+    id: "graph",
+    endpoint: "graph",
+    label: {raid: "Quest web", plain: "Dependencies"},
+    render(c, d, pane) {
+      const repo = document.querySelector('#repos [data-repo][aria-pressed="true"]')?.dataset.repo || "";
+      if (repo) {
+        const ids = new Set((d.nodes || []).filter(n => (n.repos || []).includes(repo)).map(n => n.id));
+        const edges = (d.edges || []).filter(e => ids.has(e.to));
+        const needed = new Set([...ids, ...edges.map(e => e.from)]);
+        d = {...d, nodes: (d.nodes || []).filter(n => needed.has(n.id)), edges,
+          cycles: (d.cycles || []).filter(cy => cy.every(id => needed.has(id)))};
+      }
+      const active = pane.contains(document.activeElement) ? document.activeElement.closest(".gnode")?.dataset.id : null;
+      const oldScroll = pane.querySelector(".dep-scroll");
+      const scroll = oldScroll ? [oldScroll.scrollLeft, oldScroll.scrollTop] : [0, 0];
+      const cycles = (d.cycles || []).length;
+      c.setKids(pane, [
+        c.h("div", {class: "view-head"}, c.h("h2", null, c.raid ? "Quest web" : "Dependencies", c.raid && c.raidSub ? c.raidSub("Dependencies") : null),
+          c.h("p", {class: "cls", text: `${(d.nodes || []).length} cards, ${(d.edges || []).length} ${(d.edges || []).length === 1 ? "dependency" : "dependencies"}${cycles ? `, ${cycles} cycle${cycles === 1 ? "" : "s"}` : ""}. Arrows point from a card to the cards that wait on it.`})),
+        c.h("div", {class: "legend-row"}, ["todo", "doing", "review", "blocked", "done"].map(l => c.h("span", null, c.h("i", {class: "sw lane-sw lane-" + l}), l))),
+        depGraph(c, d),
+        asText(c, d),
+        c.h("h3", {text: "Lock contention"}),
+        c.h("p", {class: "cls", text: "Lock denials, write violations and takeovers per path and day, plus cards waiting on a held path now. Darker means more."}),
+        heat(c, d)], JSON.stringify([d, c.theme, c.ws, repo]));
+      const nextScroll = pane.querySelector(".dep-scroll");
+      if (nextScroll) { nextScroll.scrollLeft = scroll[0]; nextScroll.scrollTop = scroll[1]; }
+      if (active) [...pane.querySelectorAll(".gnode")].find(n => n.dataset.id === active)?.focus({preventScroll: true});
+    }
+  });
+})();