{% extends "base.html" %}
{% block title %}safety · tau-x402-cage{% endblock %}
{% block content %}
  <style>
    /* v0.15.0: risk-dashboard category badges. Restrained palette —
       grayscale + the accent reject colour — per Tau Net house style. */
    .cat-badge {
      display: inline-block;
      padding: 1px 6px;
      border: 1px solid var(--rule);
      border-radius: 2px;
      font-size: 11px;
      line-height: 1.5;
      color: var(--muted);
      background: #ffffff;
    }
    .cat-badge.cat-prover_contradiction,
    .cat-badge.cat-cross_revision_violation {
      border-color: var(--reject);
      color: var(--reject);
    }
    .cat-badge.cat-governance_violation {
      border-color: var(--warn);
      color: var(--warn);
    }
    .cat-badge.cat-prover_inconclusive,
    .cat-badge.cat-bad_invariant {
      border-color: var(--muted);
      color: var(--muted);
    }
    .timeline-row .reason-cell {
      color: var(--muted);
      font-size: 12px;
    }
    .summary-chip {
      display: inline-block;
      padding: 0 6px;
      border: 1px solid var(--rule);
      border-radius: 2px;
      font-size: 11px;
      margin-right: 4px;
      margin-bottom: 2px;
      color: var(--muted);
    }
  </style>
  <h1 class="question">What would have spent without us?</h1>
  <p class="lede">
    Counterfactual view of the risk the cage prevented over the selected
    window. Every reject is a payment that would have gone through under
    the empty-registry baseline. Refreshes every 30 seconds.
  </p>

  {% if aggregate.get("verdict") == "error" %}
    <div class="error-banner">
      Daemon unreachable: {{ aggregate.get("category") }} / {{ aggregate.get("reason") }}
    </div>
  {% endif %}

  {% set agg = aggregate.get("aggregate") or {} %}

  <section id="summary">
    <h2>Window summary</h2>
    <dl class="meta">
      <dt>Window</dt>
      <dd>
        {% if agg.get("window_seconds") %}
          last {{ agg.get("window_seconds") }}s
        {% else %}
          all history
        {% endif %}
      </dd>
      <dt>Prevented count</dt>
      <dd>{{ agg.get("prevented_count", 0) }}</dd>
      <dt>Prevented value</dt>
      <dd>
        {% set by_ccy = agg.get("prevented_value_by_currency") or {} %}
        {% if by_ccy %}
          {% for ccy, amt in by_ccy.items() %}
            <span class="tag warn">{{ amt }} {{ ccy }}</span>
          {% endfor %}
        {% else %}
          —
        {% endif %}
      </dd>
    </dl>
  </section>

  <section id="top-providers">
    <h2>Top providers by prevented risk</h2>
    {% set providers = agg.get("top_providers") or [] %}
    {% if providers %}
      <table class="dense">
        <thead>
          <tr>
            <th>#</th>
            <th>Provider</th>
            <th>Prevented count</th>
            <th>Prevented value</th>
          </tr>
        </thead>
        <tbody>
          {% for p in providers %}
            <tr>
              <td>{{ loop.index }}</td>
              <td>{{ p.get("provider") }}</td>
              <td>{{ p.get("count") }}</td>
              <td>
                {% set vals = p.get("value_by_currency") or {} %}
                {% if vals %}
                  {% for ccy, amt in vals.items() %}
                    {{ amt }} {{ ccy }}{% if not loop.last %}, {% endif %}
                  {% endfor %}
                {% else %}—{% endif %}
              </td>
            </tr>
          {% endfor %}
        </tbody>
      </table>
    {% else %}
      <p class="empty">No rejects recorded in this window.</p>
    {% endif %}
  </section>

  <section id="top-rules">
    <h2>Top rules by firing count</h2>
    {% set rules = agg.get("top_rules") or [] %}
    {% if rules %}
      <table class="dense">
        <thead>
          <tr>
            <th>#</th>
            <th>Rule</th>
            <th>Fired</th>
            <th>Prevented value</th>
          </tr>
        </thead>
        <tbody>
          {% for r in rules %}
            <tr>
              <td>{{ loop.index }}</td>
              <td>{{ r.get("rule_id") }}</td>
              <td>{{ r.get("count") }}</td>
              <td>
                {% set vals = r.get("value_by_currency") or {} %}
                {% if vals %}
                  {% for ccy, amt in vals.items() %}
                    {{ amt }} {{ ccy }}{% if not loop.last %}, {% endif %}
                  {% endfor %}
                {% else %}—{% endif %}
              </td>
            </tr>
          {% endfor %}
        </tbody>
      </table>
    {% else %}
      <p class="empty">No rules fired in this window.</p>
    {% endif %}
  </section>

  <section id="active-constraints">
    <h2>Active constraints</h2>
    <p class="lede">
      Rules the cage is enforcing right now, grouped by class. The top 5
      scope summaries per class are shown; the <em>count</em> column is
      the full total.
    </p>
    {% set constraints_data = constraints or {} %}
    {% if constraints_data.get("verdict") == "error" %}
      <div class="error-banner">
        Daemon unreachable: {{ constraints_data.get("category") }} / {{ constraints_data.get("reason") }}
      </div>
    {% endif %}
    {% set rows = constraints_data.get("constraints") or [] %}
    {% if rows %}
      <table class="dense">
        <thead>
          <tr>
            <th>Class</th>
            <th>Count</th>
            <th>Fragment</th>
            <th>Summaries (top 5)</th>
          </tr>
        </thead>
        <tbody>
          {% for c in rows %}
            <tr>
              <td>{{ c.get("class_name") }}</td>
              <td>{{ c.get("count") }}</td>
              <td>{{ c.get("fragment") }}</td>
              <td>
                {% for s in c.get("summaries") or [] %}
                  <span class="summary-chip">{{ s }}</span>
                {% endfor %}
              </td>
            </tr>
          {% endfor %}
        </tbody>
      </table>
    {% else %}
      <p class="empty">No constraints declared.</p>
    {% endif %}
  </section>

  <section id="mutation-failures">
    <h2>Mutation failures</h2>
    <p class="lede">
      Recent rejected mutation ops: contradictions, governance violations,
      cross-revision violations, inconclusive proofs. Read-only tail of
      the daemon's in-memory ring buffer.
    </p>
    {% set failures_data = mutation_failures or {} %}
    {% if failures_data.get("verdict") == "error" %}
      <div class="error-banner">
        Daemon unreachable: {{ failures_data.get("category") }} / {{ failures_data.get("reason") }}
      </div>
    {% endif %}
    {% set entries = failures_data.get("entries") or [] %}
    {% if entries %}
      <table class="dense">
        <thead>
          <tr>
            <th>When (unix)</th>
            <th>Op</th>
            <th>Category</th>
            <th>Actor</th>
            <th>Reason</th>
          </tr>
        </thead>
        <tbody>
          {% for e in entries %}
            <tr class="timeline-row">
              <td>{{ e.get("timestamp_unix") }}</td>
              <td>{{ e.get("op") }}</td>
              <td>
                <span class="cat-badge cat-{{ e.get('category') }}">
                  {{ e.get("category") }}
                </span>
              </td>
              <td>{{ e.get("actor_id") or "—" }}</td>
              <td class="reason-cell">{{ e.get("reason") }}</td>
            </tr>
          {% endfor %}
        </tbody>
      </table>
    {% else %}
      <p class="empty">No mutation failures recorded.</p>
    {% endif %}
  </section>

  {# v0.17.0: runtime guard state panel. Gated on the daemon exposing a
     `runtime_state` op; older cages render the unavailable notice. #}
  <style>
    /* Tightening levels share the house palette: muted for none,
       amber/warn for mild+moderate, reject for severe. Colours are
       inherited from the global stylesheet so no new tokens are added. */
    .tight-none     { color: var(--muted); }
    .tight-mild     { color: var(--warn); }
    .tight-moderate { color: var(--warn); font-weight: 600; }
    .tight-severe   { color: var(--reject); font-weight: 600; }
    .rtg-row td { vertical-align: top; }
  </style>

  <section id="runtime-guard-state">
    <h2>Runtime guard state</h2>
    <p class="lede">
      Live velocity, retry density, and tightening level. Read-only;
      refreshes every 15 seconds because runtime state moves faster
      than the rest of this page.
    </p>
    {% set rt = runtime_state or {} %}
    {% if rt.get("verdict") == "error" and rt.get("category") == "unknown_op" %}
      <p class="empty">
        Runtime guard state unavailable on this cage version. Upgrade to
        v0.17.0 or later to surface spend velocity + tightening level here.
      </p>
    {% elif rt.get("verdict") == "error" %}
      <div class="error-banner">
        Daemon unreachable: {{ rt.get("category") }} / {{ rt.get("reason") }}
      </div>
    {% else %}
      {% set level = (rt.get("tightening_level") or "none")|lower %}
      <dl class="meta">
        <dt>Tightening level</dt>
        <dd>
          <span class="tight-{{ level }}">{{ level }}</span>
        </dd>
        <dt>Spend velocity (rate / sec)</dt>
        <dd>
          {% set vel = rt.get("spend_velocity") or {} %}
          {{ vel.get("rate_per_second", "0") }} {{ vel.get("currency", "") }}
          <span class="tag">window total: {{ vel.get("window_total", "0") }}</span>
        </dd>
      </dl>

      {% set retries = rt.get("retry_density") or [] %}
      <h3>Top repeating intent-tuples</h3>
      {% if retries %}
        <table class="dense">
          <thead>
            <tr>
              <th>#</th>
              <th>Provider</th>
              <th>Counterparty</th>
              <th>Endpoint</th>
              <th>Count</th>
            </tr>
          </thead>
          <tbody>
            {% for r in retries[:5] %}
              <tr class="rtg-row">
                <td>{{ loop.index }}</td>
                <td>{{ r.get("provider") or "—" }}</td>
                <td>{{ r.get("counterparty") or "—" }}</td>
                <td>{{ r.get("endpoint") or "—" }}</td>
                <td>{{ r.get("count", 0) }}</td>
              </tr>
            {% endfor %}
          </tbody>
        </table>
      {% else %}
        <p class="empty">No repeating intent tuples in the current window.</p>
      {% endif %}

      {% set cooldowns = rt.get("active_cooldowns") or [] %}
      <h3>Active cooldowns</h3>
      {% if cooldowns %}
        <table class="dense">
          <thead>
            <tr>
              <th>Source</th>
              <th>Expires in (s)</th>
            </tr>
          </thead>
          <tbody>
            {% for cd in cooldowns %}
              <tr class="rtg-row">
                <td>{{ cd.get("source") or "—" }}</td>
                <td>{{ cd.get("expires_in_seconds", 0) }}</td>
              </tr>
            {% endfor %}
          </tbody>
        </table>
      {% else %}
        <p class="empty">No active cooldowns.</p>
      {% endif %}
    {% endif %}
  </section>

  <script>
    // Runtime state is more dynamic than the other panels on this page
    // (velocity + cooldowns move between refreshes), so v0.17.0 shortens
    // the auto-reload cadence from 30s -> 15s. Still no JS dependencies.
    setTimeout(function() { window.location.reload(); }, 15000);
  </script>
{% endblock %}