Status: Implemented; activates when read credentials are configured

`/admin/analytics` gives operators the trailing-twenty-four-hour product

picture without opening PostHog. It exists because the numbers an operator

acts on should be one navigation away, rendered in this product's own

components, and gated behind the same operator boundary as every other admin

surface.

`/admin/analytics` gives operators the product-usage and issue-triage picture

without opening PostHog. It exists because the numbers an operator acts on

should be one navigation away, rendered in this product's own components, and

gated behind the same operator boundary as every other admin surface.

## How it works

of its own: what it renders is exactly what the PostHog app answers for the

same window, so there is no second authority that can drift from the source.

One pull runs four bounded questions:

One pull runs six bounded questions:

1. **Activation funnel** — authorization starts, accounts created, returning

   sign-ins, first chat messages sent.

   average and longest turn duration.

3. **Event volume** — every event name with count and distinct people.

4. **Top pages** — the eight most-viewed URLs.

5. **Triage health** — rolling 90-day median first-maintainer response time

   and the share of open issues still unlabeled after 24 hours.

6. **Weekly issue flow** — issues created and closed during each of the

   trailing eight weeks.

The issue projections rely on `issue_number`, `issue_state`,

`issue_state_changed`, `has_labels`, and `is_maintainer`. Historical events

without those properties are excluded rather than interpreted as zeros.

## Configuration

| Unavailable | Danger notice with retry | PostHog did not answer; nothing stale is rendered |

| Loaded | Cards and tables | Fresh pull with a generated-at stamp |

Refresh re-runs all four questions and replaces the whole projection.

Refresh re-runs all six questions and replaces the whole projection.

## Boundaries

`test/openagents_web/live/admin_analytics_live_test.exs` covers the access

gates and all three non-loaded states plus refresh.

## Weekly review

Use the pinned **Issue triage health** PostHog dashboard (dashboard `2022873`)

for the weekly review. Its saved insights are **Triage health snapshot**

(`11257107`) and **Weekly issue flow** (`11257108`).

1. Compare the median first-maintainer response with the prior week.

2. Compare issue intake with closure volume and investigate a sustained gap.

3. Label or close every eligible issue shown in the unlabeled count.

4. Treat missing response data as insufficient instrumented history.

5. Annotate policy, instrumentation, or staffing changes that can explain a

   trend break.

6. Track follow-up work in forge issues.

## Related

- [PostHog integration runbook](2026-08-21-posthog-integration-runbook.md) —

Date: 2026-08-21

Status: Implemented in code; staging enablement, dashboards, and live verification remain

Status: Implemented in code; live staging verification remains

PostHog ships an agentic installer, the [AI wizard](https://github.com/PostHog/wizard), that wires PostHog into a codebase end to end. The wizard does not support Phoenix or Elixir: the framework is registered as "coming soon" in PostHog's own documentation, so running `npx @posthog/wizard` against this repository would not produce a usable integration.

This document is the manual replacement. Part 1 records what the wizard does so we know the full surface we are replicating. Part 2 turns that into a concrete runbook for this Phoenix application: server-side capture from Elixir, browser analytics through our asset bundle, pageviews that survive LiveView navigation, user identification, and an event taxonomy covering every product surface. Session replay and self-driving are out of scope.

Steps 1 through 7 of part 2 are implemented. What remains is operational:

Steps 1 through 8 of part 2 are implemented. What remains is operational:

1. Set `OPENAGENTS_POSTHOG_PROJECT_TOKEN` (and optionally `OPENAGENTS_POSTHOG_API_HOST`) in the staging environment.

2. Build the starter dashboards through the PostHog MCP (step 8).

3. Run the verification checklist against a live staging deployment (step 9).

2. Run the verification checklist against a live staging deployment (step 9).

Use this document as the single checklist for that work. Nothing in it requires the wizard.

| Event | Where | Properties |

| --- | --- | --- |

| `issue_created` | `Issues.create_issue` | `owner`, `repo`, `has_labels`, `has_assignees` |

| `issue_updated` | `Issues.update_issue` | `owner`, `repo`, `state` |

| `issue_commented` | `Issues.create_comment` | `issue_number` |

| `issue_created` | `Issues.create_issue` | `owner`, `repo`, `issue_number`, `issue_state`, `has_labels`, `has_assignees` |

| `issue_updated` | `Issues.update_issue` | `owner`, `repo`, `issue_number`, `previous_issue_state`, `issue_state`, `issue_state_changed`, `has_labels` |

| `issue_commented` | `Issues.create_comment` | `owner`, `repo`, `issue_number`, `author_role`, `is_maintainer` |

| `label_created`, `milestone_created`, `project_created` | respective contexts | `owner`, `repo` |

| `project_item_added` | `Projects.create_project_item` | `project_number`, `has_issue` |

| `git_push_received` | `Forge.Pushes` live push path | `repo`, `refs_changed`, `duration_ms` |

- API read endpoints (`GET`) stay uninstrumented except where they represent product activation.

- Never capture message bodies, objective text, token material, ciphertexts, or raw query strings. `$current_url` contains query parameters; rely on the wrapper's redaction denylist and keep sensitive routes out of custom properties.

### Step 8: Build the starter dashboards through the PostHog MCP

### Step 8: Build the dashboards (implemented)

Build every dashboard from your coding agent through the PostHog MCP server instead of clicking in the web app. Dashboard, insight, and annotation objects are all writable through MCP tools, so this step becomes a scripted session you can rerun and review like code.

Keep the dashboard definitions in the agent session transcript or commit them as a script; because creation goes through MCP calls, recreating the set in staging or after a project reset is mechanical.

The operations project also has the pinned **Issue triage health** dashboard

(dashboard `2022873`). It contains:

- **Triage health snapshot** (insight `11257107`): the rolling 90-day median

  time from `issue_created` to the first `issue_commented` event whose

  `is_maintainer` property is true, plus the share of open issues that remain

  unlabeled 24 hours after creation.

- **Weekly issue flow** (insight `11257108`): issues created and closed for

  each of the trailing eight weeks. A closure is an `issue_updated` event with

  `issue_state_changed = true` and `issue_state = "closed"`.

The dashboard and its two HogQL insights were created through the PostHog REST

API because the MCP server was unavailable during setup. This does not change

their ownership or query semantics.

Historical issue events do not contain the new triage properties. Expect the

response, label, and closure metrics to populate from the deployment that

introduces those properties; do not infer historical zeros from missing data.

### Weekly triage review

Review the pinned dashboard once each week:

1. Record the median first-maintainer response and compare it with the prior

   week.

2. Compare issues created with issues closed. Investigate sustained intake

   above closure volume.

3. Open the unlabeled count and label or close each eligible issue.

4. Treat a blank response metric as insufficient instrumented data, not a zero.

5. Add an annotation for instrumentation, policy, or staffing changes that can

   explain a trend break.

6. Record follow-up work as forge issues and link the dashboard in the issue.

### Step 9: Verify

Work through this checklist in staging. Browser-side checks stay manual; every server-side or ingestion check runs through the PostHog MCP against the events table, which beats tailing the web UI:

## Operator analytics surface

`/admin/analytics` gives operators the trailing-24-hour picture without opening PostHog. It pulls computed results from the PostHog REST API at request time through `OpenAgents.PostHog` (a personal API key over HogQL), so it adds no second aggregation authority: the numbers match what the PostHog app answers for the same window.

`/admin/analytics` gives operators the usage and triage picture without opening

PostHog. It pulls computed results from the PostHog REST API at request time

through `OpenAgents.PostHog` (a personal API key over HogQL), so it adds no

second aggregation authority: the numbers match what the PostHog app answers

for the same window.

Settings (all optional; absent credentials disable the read path only, independently of capture):

| `OPENAGENTS_POSTHOG_PROJECT_ID` | The numeric PostHog project id |

| `OPENAGENTS_POSTHOG_APP_HOST` | Optional; defaults to `https://us.posthog.com`. This is the app/API host, not the ingest host |

The page renders four bounded projections — activation funnel, chat turn outcomes and durations, event volume, top pages — plus its non-happy states as first-class UI: unconfigured credentials, an unanswered query (with retry, never stale numbers), and loading. It shows aggregates only; no conversation content is reachable from it. The route is operator-gated like the rest of `/admin` and classified in the route authority inventory as `analytics:read`.

The page renders six bounded projections: activation funnel, chat turn outcomes

and durations, event volume, top pages, triage health, and weekly issue flow.

Usage projections cover the trailing 24 hours, triage health covers 90 days,

and issue flow covers eight weeks. It renders unconfigured credentials, an

unanswered query (with retry, never stale numbers), and loading as first-class

states. It shows aggregates only; no conversation content is reachable from

it. The route is operator-gated like the rest of `/admin` and classified in the

route authority inventory as `analytics:read`.

### Rollout order

1. Steps 1-6 are implemented and covered by the test suite; they activate the moment a project token is configured.

2. Set `OPENAGENTS_POSTHOG_PROJECT_TOKEN` in staging and confirm boot with capture live.

3. Step 7 events flow automatically; watch volume in the first days.

4. Step 8: build dashboards through the MCP.

4. Step 8 is complete; review the pinned triage dashboard weekly.

5. Step 9 gates each stage; do not stack stages without verification.

## References

defmodule OpenAgents.DoNotBuildRegister do

  @moduledoc """

  Reads and screens proposals against the durable do-not-build register.

  Matching uses explicit multi-word phrases from the register. It does not

  expand keywords, stem words, or infer semantic similarity, so unrelated work

  is not blocked because it mentions a product name.

  """

  alias OpenAgents.Analytics

  @register_path "priv/api-contracts/do-not-build-v1.json"

  @decision_states ~w(retired deferred rejected superseded)

  @doc "The decoded and validated public register."

  def load do

    with {:ok, bytes} <- File.read(register_file()),

         {:ok, register} <- Jason.decode(bytes),

         :ok <- validate(register) do

      {:ok, register}

    end

  end

  @doc "The register entries, raising when the committed contract is invalid."

  def entries do

    {:ok, register} = load()

    register["entries"]

  end

  @doc "The first precise register match for a proposal, or nil."

  def match(proposal) do

    text = proposal_text(proposal)

    Enum.find(entries(), fn entry ->

      Enum.any?(entry["match_phrases"], &String.contains?(text, normalize(&1)))

    end)

  end

  @doc """

  Screens a FastFollow backlog proposal.

  A match is suppressed and recorded without proposal text. New evidence and

  an explicit decision record move the result to manual register review; they

  do not silently override the committed decision.

  """

  def screen_fast_follow(proposal, opts \\ []) when is_list(opts) do

    case match(proposal) do

      nil ->

        :allow

      entry ->

        if reconsideration_ready?(opts) do

          {:review_required, entry}

        else

          record_suppression(entry, proposal)

          {:suppressed, entry}

        end

    end

  end

  @doc "Validates the public contract and its append-only decision history."

  def validate(%{

        "contract" => "openagents.do-not-build.v1",

        "version" => 1,

        "decision_states" => @decision_states,

        "entries" => entries

      })

      when is_list(entries) do

    with :ok <- validate_unique_ids(entries),

         :ok <- validate_entries(entries) do

      :ok

    end

  end

  def validate(_register), do: {:error, :invalid_contract}

  defp validate_unique_ids(entries) do

    ids = Enum.map(entries, & &1["id"])

    if length(ids) == length(Enum.uniq(ids)),

      do: :ok,

      else: {:error, :duplicate_ids}

  end

  defp validate_entries(entries) do

    if Enum.all?(entries, &valid_entry?/1),

      do: :ok,

      else: {:error, :invalid_entry}

  end

  defp valid_entry?(%{

         "id" => id,

         "retired_scope" => scope,

         "match_phrases" => phrases,

         "current" => current,

         "history" => history

       })

       when is_binary(id) and is_binary(scope) and is_list(phrases) and is_map(current) and

              is_list(history) and history != [] do

    valid_phrases?(phrases) and valid_decision?(current) and List.last(history) == current and

      Enum.all?(history, &valid_decision?/1)

  end

  defp valid_entry?(_entry), do: false

  defp valid_phrases?(phrases) do

    phrases != [] and

      Enum.all?(phrases, fn phrase ->

        is_binary(phrase) and String.length(phrase) >= 8 and

          phrase |> String.split() |> length() >= 2

      end)

  end

  defp valid_decision?(%{

         "state" => state,

         "decision_date" => date,

         "evidence" => evidence,

         "violated_principle" => principle,

         "replacement_path" => replacement,

         "owner" => owner,

         "reconsideration_trigger" => trigger,

         "decision_record" => record

       }) do

    state in @decision_states and valid_date?(date) and non_empty_list?(evidence) and

      Enum.all?(evidence, &valid_evidence?/1) and

      Enum.all?([principle, replacement, owner, trigger, record], &non_empty_string?/1)

  end

  defp valid_decision?(_decision), do: false

  defp valid_evidence?(%{"source" => source, "summary" => summary}),

    do: non_empty_string?(source) and non_empty_string?(summary)

  defp valid_evidence?(_evidence), do: false

  defp valid_date?(date) when is_binary(date), do: match?({:ok, _}, Date.from_iso8601(date))

  defp valid_date?(_date), do: false

  defp non_empty_list?(value), do: is_list(value) and value != []

  defp non_empty_string?(value), do: is_binary(value) and String.trim(value) != ""

  defp reconsideration_ready?(opts) do

    non_empty_string?(Keyword.get(opts, :new_evidence)) and

      non_empty_string?(Keyword.get(opts, :decision_record))

  end

  defp record_suppression(entry, proposal) do

    Analytics.capture(

      "fast_follow_proposal_suppressed",

      Analytics.system_distinct_id("fast_follow"),

      %{

        "register_id" => entry["id"],

        "decision_state" => entry["current"]["state"],

        "proposal_fingerprint" => fingerprint(proposal)

      }

    )

  end

  defp fingerprint(proposal) do

    proposal

    |> proposal_text()

    |> then(&:crypto.hash(:sha256, &1))

    |> Base.encode16(case: :lower)

  end

  defp proposal_text(proposal) when is_binary(proposal), do: normalize(proposal)

  defp proposal_text(proposal) when is_map(proposal) do

    [proposal[:title], proposal["title"], proposal[:body], proposal["body"]]

    |> Enum.filter(&is_binary/1)

    |> Enum.join(" ")

    |> normalize()

  end

  defp proposal_text(_proposal), do: ""

  defp normalize(text) do

    text

    |> String.downcase()

    |> String.replace(~r/[^\p{L}\p{N}]+/u, " ")

    |> String.trim()

  end

  defp register_file, do: Application.app_dir(:openagents, @register_path)

end

        Analytics.capture("issue_created", issue_distinct_id(normalized), %{

          "owner" => repository.owner,

          "repo" => repository.name,

          "issue_number" => issue.number,

          "issue_state" => issue.state,

          "has_labels" => has_labels?(normalized),

          "has_assignees" => has_assignees?(normalized)

        })

        Analytics.capture("issue_updated", actor_distinct_id(actor), %{

          "owner" => repository && repository.owner,

          "repo" => repository && repository.name,

          "state" => updated.state

          "issue_number" => updated.number,

          "previous_issue_state" => issue.state,

          "issue_state" => updated.state,

          "issue_state_changed" => issue.state != updated.state,

          "has_labels" => updated.labels != []

        })

        Repositories.broadcast_issues(issue.repository_id)

    end)

    |> case do

      {:ok, comment} ->

        repository = Repo.get(Repository, issue.repository_id)

        author_role = repository && author && Repositories.membership_role(repository, author)

        Analytics.capture("issue_commented", issue_distinct_id(normalized), %{

          "issue_number" => issue.number

          "owner" => repository && repository.owner,

          "repo" => repository && repository.name,

          "issue_number" => issue.number,

          "author_role" => author_role,

          "is_maintainer" => author_role in ~w(owner maintainer)

        })

        Repositories.broadcast_issues(issue.repository_id)

  end

  @doc """

  Everything the operator analytics page shows, for the trailing 24 hours.

  Everything the operator analytics page shows.

  Returns `{:ok, shaped}` with four bounded projections, or

  Returns `{:ok, shaped}` with six bounded projections, or

  `{:error, :not_configured | :unavailable}`. Each projection runs as its own

  HogQL query; a failure of any one fails the whole pull, because partial

  numbers presented next to each other read as complete.

      with {:ok, events} <- run(event_counts_sql(), "event_counts"),

           {:ok, funnel} <- run(funnel_sql(), "funnel"),

           {:ok, chat} <- run(chat_turns_sql(), "chat_turns"),

           {:ok, pages} <- run(top_pages_sql(), "top_pages") do

           {:ok, pages} <- run(top_pages_sql(), "top_pages"),

           {:ok, triage} <- run(triage_health_sql(), "triage_health"),

           {:ok, issue_flow} <- run(weekly_issue_flow_sql(), "weekly_issue_flow") do

        {:ok,

         %{

           generated_at: DateTime.utc_now(),

           event_counts: shape_rows(events),

           funnel: shape_rows(funnel) |> List.first(%{}),

           chat_turns: shape_chat_turns(shape_rows(chat) |> List.first(%{})),

           top_pages: shape_rows(pages)

           top_pages: shape_rows(pages),

           triage_health: shape_triage_health(shape_rows(triage) |> List.first(%{})),

           weekly_issue_flow: shape_rows(issue_flow)

         }}

      end

    else

    |> squash()

  end

  defp triage_health_sql do

    """

    WITH issue_events AS (

      SELECT

        properties.owner AS owner,

        properties.repo AS repo,

        properties.issue_number AS issue_number,

        minIf(timestamp, event = 'issue_created') AS created_at,

        argMax(properties.has_labels, timestamp) AS has_labels,

        argMax(properties.issue_state, timestamp) AS issue_state

      FROM events

      WHERE event IN ('issue_created', 'issue_updated')

        AND timestamp >= now() - INTERVAL 90 DAY

        AND notEmpty(properties.owner)

        AND notEmpty(properties.repo)

        AND properties.issue_number IS NOT NULL

      GROUP BY owner, repo, issue_number

    ),

    first_responses AS (

      SELECT

        properties.owner AS owner,

        properties.repo AS repo,

        properties.issue_number AS issue_number,

        min(timestamp) AS responded_at

      FROM events

      WHERE event = 'issue_commented'

        AND timestamp >= now() - INTERVAL 90 DAY

        AND properties.is_maintainer = true

        AND properties.issue_number IS NOT NULL

      GROUP BY owner, repo, issue_number

    ),

    response_times AS (

      SELECT dateDiff('second', issues.created_at, responses.responded_at) AS seconds

      FROM issue_events AS issues

      INNER JOIN first_responses AS responses

        ON issues.owner = responses.owner

        AND issues.repo = responses.repo

        AND issues.issue_number = responses.issue_number

      WHERE responses.responded_at >= issues.created_at

    ),

    label_health AS (

      SELECT

        countIf(created_at <= now() - INTERVAL 1 DAY AND issue_state = 'open') AS eligible,

        countIf(

          created_at <= now() - INTERVAL 1 DAY

          AND issue_state = 'open'

          AND has_labels = false

        ) AS unlabeled

      FROM issue_events

    )

    SELECT

      round(median(seconds) / 3600, 1) AS median_first_maintainer_response_hours,

      (SELECT eligible FROM label_health) AS eligible_issues,

      (SELECT unlabeled FROM label_health) AS unlabeled_issues,

      if(

        eligible_issues = 0,

        0,

        round(unlabeled_issues * 100.0 / eligible_issues, 1)

      ) AS unlabeled_after_24h_percent

    FROM response_times

    """

    |> squash()

  end

  defp weekly_issue_flow_sql do

    """

    SELECT

      formatDateTime(toStartOfWeek(timestamp), '%Y-%m-%d') AS week,

      countIf(event = 'issue_created') AS created,

      countIf(

        event = 'issue_updated'

        AND properties.issue_state_changed = true

        AND properties.issue_state = 'closed'

      ) AS closed

    FROM events

    WHERE timestamp >= now() - INTERVAL 8 WEEK

      AND event IN ('issue_created', 'issue_updated')

    GROUP BY week

    ORDER BY week ASC

    """

    |> squash()

  end

  # ── shaping ──────────────────────────────────────────────────────────────

  defp shape_rows(%{"results" => results, "columns" => columns}) when is_list(results) do

    }

  end

  defp shape_triage_health(row) do

    %{

      "median_first_maintainer_response_hours" =>

        numeric_or_nil(row["median_first_maintainer_response_hours"]),

      "eligible_issues" => count_value(row["eligible_issues"]),

      "unlabeled_issues" => count_value(row["unlabeled_issues"]),

      "unlabeled_after_24h_percent" => numeric_value(row["unlabeled_after_24h_percent"])

    }

  end

  defp scalar(value) when is_integer(value) or is_float(value), do: value

  defp scalar(value) when is_binary(value), do: value

  defp scalar(nil), do: nil

  defp duration_value(value) when is_float(value), do: round(value)

  defp duration_value(_other), do: nil

  defp numeric_value(value) when is_integer(value) or is_float(value), do: value

  defp numeric_value(_other), do: 0

  defp numeric_or_nil(value) when is_integer(value) or is_float(value), do: value

  defp numeric_or_nil(_other), do: nil

  # ── transport ────────────────────────────────────────────────────────────

  defp run(sql, label) do

  use OpenAgentsWeb, :controller

  @contract_path "priv/api-contracts/repositories-v1.json"

  @do_not_build_path "priv/api-contracts/do-not-build-v1.json"

  def repositories_v1(conn, _params) do

    contract = File.read!(contract_file())

    send_contract(conn, @contract_path)

  end

  def do_not_build_v1(conn, _params) do

    send_contract(conn, @do_not_build_path)

  end

  defp send_contract(conn, path) do

    contract = File.read!(contract_file(path))

    conn

    |> put_resp_content_type("application/json")

  # release, and that path does not exist in the image that runs it -- so

  # `File.read!/1` raised and this endpoint answered 500 in every deployed

  # environment while passing everywhere it was compiled and run together.

  defp contract_file, do: Application.app_dir(:openagents, @contract_path)

  defp contract_file(path), do: Application.app_dir(:openagents, path)

  defp sha256(bytes) do

    bytes

          title: "Assignees",

          icon: "user",

          route: "/:owner/:repo/assignees"

        },

        %{

          slug: "do-not-build-register",

          title: "Do-not-build register",

          icon: "info",

          route: "/api/contracts/do-not-build-v1.json"

        }

      ]

    },

          <header class="admin-heading">

            <h1 id="analytics-heading">Product analytics</h1>

            <p>

              Computed live from PostHog over the trailing twenty-four hours. These are

              aggregate operational facts about usage; no conversation or memory content

              is readable from this page.

              Computed live from PostHog. Usage covers the trailing twenty-four hours,

              and triage health uses the rolling windows shown below. These are aggregate

              operational facts; no conversation or memory content is readable from this page.

            </p>

            <div class="admin-totals">

              <.badge variant={:info}>TRAILING 24 HOURS</.badge>

              <.badge variant={:info}>LIVE POSTHOG</.badge>

              <.badge

                :if={@status == :loaded && @overview}

                variant={:dim}

          </.alert>

          <.alert :if={@status == :loading} id="analytics-loading" appearance={:row}>

            Querying PostHog for the trailing twenty-four hours…

            Querying PostHog…

          </.alert>

          <div :if={@status == :loaded && @overview} class="space-y-8">

            <section aria-labelledby="triage-health-heading">

              <.card id="analytics-triage-health">

                <div class="space-y-1">

                  <h2 id="triage-health-heading" class="card-title">Triage health</h2>

                  <p class="text-muted-foreground">

                    Response and label health use issues created in the trailing 90 days.

                    Issue flow covers the trailing eight weeks.

                  </p>

                </div>

                <% triage = @overview.triage_health %>

                <div class="grid gap-4 py-5 md:grid-cols-3">

                  <div class="rounded-md border border-border p-4">

                    <p class="text-sm text-muted-foreground">Median first maintainer response</p>

                    <p id="triage-median-response" class="mt-2 text-2xl font-semibold">

                      {format_hours(triage["median_first_maintainer_response_hours"])}

                    </p>

                  </div>

                  <div class="rounded-md border border-border p-4">

                    <p class="text-sm text-muted-foreground">Unlabeled after 24 hours</p>

                    <p id="triage-unlabeled-share" class="mt-2 text-2xl font-semibold">

                      {format_percent(triage["unlabeled_after_24h_percent"])}

                    </p>

                  </div>

                  <div class="rounded-md border border-border p-4">

                    <p class="text-sm text-muted-foreground">Eligible open issues</p>

                    <p id="triage-eligible-issues" class="mt-2 text-2xl font-semibold">

                      {triage["eligible_issues"]}

                    </p>

                    <p class="mt-1 text-sm text-muted-foreground">

                      {triage["unlabeled_issues"]} currently have no labels.

                    </p>

                  </div>

                </div>

                <.table id="analytics-weekly-issue-flow" rows={@overview.weekly_issue_flow}>

                  <:col :let={row} label="Week of">{row["week"]}</:col>

                  <:col :let={row} label="Created">{row["created"]}</:col>

                  <:col :let={row} label="Closed">{row["closed"]}</:col>

                </.table>

              </.card>

            </section>

            <section aria-labelledby="funnel-heading">

              <.card id="analytics-funnel">

                <h2 id="funnel-heading" class="card-title">Activation funnel</h2>

  end

  defp format_duration(ms) when is_integer(ms), do: "#{ms}ms"

  defp format_hours(nil), do: "No data"

  defp format_hours(hours) when is_integer(hours), do: "#{hours}h"

  defp format_hours(hours) when is_float(hours),

    do: "#{:erlang.float_to_binary(hours, decimals: 1)}h"

  defp format_percent(value) when is_integer(value), do: "#{value}%"

  defp format_percent(value) when is_float(value),

    do: "#{:erlang.float_to_binary(value, decimals: 1)}%"

end

  defp policy(%{path: "/api/changelog", verb: verb}) when verb in [:get, :head],

    do: declaration(:public_read, "anonymous", "published:changelog", false)

  defp policy(%{path: "/api/contracts/repositories-v1.json", verb: verb})

       when verb in [:get, :head],

  defp policy(%{path: path, verb: verb})

       when path in [

              "/api/contracts/repositories-v1.json",

              "/api/contracts/do-not-build-v1.json"

            ] and

              verb in [:get, :head],

       do: declaration(:public_read, "anonymous", "published:api-contract", false)

  defp policy(%{path: "/api/v3", verb: verb}) when verb in [:get, :head],

    get "/api/status", NetworkStatusController, :show

    get "/api/changelog", ChangelogController, :show

    get "/api/contracts/repositories-v1.json", ApiContractController, :repositories_v1

    get "/api/contracts/do-not-build-v1.json", ApiContractController, :do_not_build_v1

    post "/controller/pairings", ControllerPairingController, :create

    get "/controller/pairings/:id", ControllerPairingController, :show

{

  "contract": "openagents.do-not-build.v1",

  "version": 1,

  "published_at": "2026-08-23",

  "decision_states": [

    "retired",

    "deferred",

    "rejected",

    "superseded"

  ],

  "issue_template": {

    "heading": "Do-not-build review",

    "fields": [

      "Register checked: yes",

      "Matching entry: none or DNB-###",

      "New evidence: required for reconsideration",

      "Decision record: required for reconsideration"

    ]

  },

  "entries": [

    {

      "id": "DNB-001",

      "retired_scope": "Spark or another hosted wallet as the custody layer for agents.",

      "match_phrases": [

        "hosted spark wallet",

        "spark custodial wallet",

        "custody spark wallets",

        "spark custody service"

      ],

      "current": {

        "state": "superseded",

        "decision_date": "2026-08-23",

        "evidence": [

          {

            "source": "docs/episode-triage.md",

            "summary": "Episode triage records the move from Spark custody to the self-custodial MoneyDevKit and LDK stack."

          }

        ],

        "violated_principle": "Agents and users retain custody; hosted custody must not become a platform dependency.",

        "replacement_path": "Use the MoneyDevKit and LDK self-custodial wallet stack.",

        "owner": "OpenAgents product council",

        "reconsideration_trigger": "A self-custodial Spark design with production evidence and no hosted custody dependency.",

        "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

      },

      "history": [

        {

          "state": "superseded",

          "decision_date": "2026-08-23",

          "evidence": [

            {

              "source": "docs/episode-triage.md",

              "summary": "Episode triage records the move from Spark custody to the self-custodial MoneyDevKit and LDK stack."

            }

          ],

          "violated_principle": "Agents and users retain custody; hosted custody must not become a platform dependency.",

          "replacement_path": "Use the MoneyDevKit and LDK self-custodial wallet stack.",

          "owner": "OpenAgents product council",

          "reconsideration_trigger": "A self-custodial Spark design with production evidence and no hosted custody dependency.",

          "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

        }

      ]

    },

    {

      "id": "DNB-002",

      "retired_scope": "A NIP-90 data-vending-machine market without a named buyer and working product.",

      "match_phrases": [

        "nip-90 dvm market",

        "nip-90 data vending machine market",

        "data vending machine marketplace",

        "dvm data market"

      ],

      "current": {

        "state": "retired",

        "decision_date": "2026-08-23",

        "evidence": [

          {

            "source": "docs/episode-triage.md",

            "summary": "Seller-first markets and protocol-only launches did not establish durable buyer demand."

          }

        ],

        "violated_principle": "Name the buyer and ship usable software before creating a market protocol.",

        "replacement_path": "Use the accepted-outcome economy for a verified demand path with a named buyer.",

        "owner": "OpenAgents product council",

        "reconsideration_trigger": "A committed buyer, executable product flow, and paid end-to-end transaction.",

        "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

      },

      "history": [

        {

          "state": "retired",

          "decision_date": "2026-08-23",

          "evidence": [

            {

              "source": "docs/episode-triage.md",

              "summary": "Seller-first markets and protocol-only launches did not establish durable buyer demand."

            }

          ],

          "violated_principle": "Name the buyer and ship usable software before creating a market protocol.",

          "replacement_path": "Use the accepted-outcome economy for a verified demand path with a named buyer.",

          "owner": "OpenAgents product council",

          "reconsideration_trigger": "A committed buyer, executable product flow, and paid end-to-end transaction.",

          "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

        }

      ]

    },

    {

      "id": "DNB-003",

      "retired_scope": "Bun in the production runtime or package-manager trust path.",

      "match_phrases": [

        "bun production runtime",

        "bun in the production trust path",

        "replace npm with bun in production",

        "deploy openagents with bun"

      ],

      "current": {

        "state": "rejected",

        "decision_date": "2026-08-23",

        "evidence": [

          {

            "source": "docs/episode-triage.md",

            "summary": "The production stack standardized on the existing Node and npm asset path."

          }

        ],

        "violated_principle": "Minimize production trust changes that do not improve the product.",

        "replacement_path": "Keep Node.js and npm for the browser asset build.",

        "owner": "OpenAgents engineering",

        "reconsideration_trigger": "A measured production requirement that Node and npm cannot satisfy.",

        "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

      },

      "history": [

        {

          "state": "rejected",

          "decision_date": "2026-08-23",

          "evidence": [

            {

              "source": "docs/episode-triage.md",

              "summary": "The production stack standardized on the existing Node and npm asset path."

            }

          ],

          "violated_principle": "Minimize production trust changes that do not improve the product.",

          "replacement_path": "Keep Node.js and npm for the browser asset build.",

          "owner": "OpenAgents engineering",

          "reconsideration_trigger": "A measured production requirement that Node and npm cannot satisfy.",

          "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

        }

      ]

    },

    {

      "id": "DNB-004",

      "retired_scope": "GetAfter as a second source-control forge.",

      "match_phrases": [

        "build getafter as a forge",

        "getafter second forge",

        "revive getafter",

        "add another forge as getafter"

      ],

      "current": {

        "state": "superseded",

        "decision_date": "2026-08-23",

        "evidence": [

          {

            "source": "docs/episode-triage.md",

            "summary": "The OpenAgents forge replaced the shelved GetAfter alternative."

          }

        ],

        "violated_principle": "One canonical forge owns source control and work state.",

        "replacement_path": "Extend the OpenAgents forge instead of operating a second forge.",

        "owner": "OpenAgents engineering",

        "reconsideration_trigger": "A legally or operationally mandatory isolation boundary the current forge cannot provide.",

        "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

      },

      "history": [

        {

          "state": "superseded",

          "decision_date": "2026-08-23",

          "evidence": [

            {

              "source": "docs/episode-triage.md",

              "summary": "The OpenAgents forge replaced the shelved GetAfter alternative."

            }

          ],

          "violated_principle": "One canonical forge owns source control and work state.",

          "replacement_path": "Extend the OpenAgents forge instead of operating a second forge.",

          "owner": "OpenAgents engineering",

          "reconsideration_trigger": "A legally or operationally mandatory isolation boundary the current forge cannot provide.",

          "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

        }

      ]

    },

    {

      "id": "DNB-005",

      "retired_scope": "Paying providers for online presence, uptime, or unverified mining.",

      "match_phrases": [

        "pay for online presence",

        "presence based mining",

        "reward nodes for being online",

        "mining payments for uptime"

      ],

      "current": {

        "state": "retired",

        "decision_date": "2026-08-23",

        "evidence": [

          {

            "source": "docs/episode-triage.md",

            "summary": "Episode 224 retired presence-based rewards in favor of verified machine-learning work."

          }

        ],

        "violated_principle": "Settle verified outcomes, not claimed availability.",

        "replacement_path": "Pay against accepted work receipts with verification and settlement evidence.",

        "owner": "OpenAgents product council",

        "reconsideration_trigger": "A fraud-resistant proof that presence itself creates measurable buyer value.",

        "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

      },

      "history": [

        {

          "state": "retired",

          "decision_date": "2026-08-23",

          "evidence": [

            {

              "source": "docs/episode-triage.md",

              "summary": "Episode 224 retired presence-based rewards in favor of verified machine-learning work."

            }

          ],

          "violated_principle": "Settle verified outcomes, not claimed availability.",

          "replacement_path": "Pay against accepted work receipts with verification and settlement evidence.",

          "owner": "OpenAgents product council",

          "reconsideration_trigger": "A fraud-resistant proof that presence itself creates measurable buyer value.",

          "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

        }

      ]

    },

    {

      "id": "DNB-006",

      "retired_scope": "GitHub Copilot as an executor target for delegated work.",

      "match_phrases": [

        "copilot executor target",

        "execute work through github copilot",

        "add copilot as an executor",

        "copilot coding agent target"

      ],

      "current": {

        "state": "deferred",

        "decision_date": "2026-08-23",

        "evidence": [

          {

            "source": "docs/episode-triage.md",

            "summary": "The active fleet uses controllable harnesses with explicit execution and receipt contracts."

          }

        ],

        "violated_principle": "Executor targets must expose controllable lifecycle, evidence, and recovery contracts.",

        "replacement_path": "Use the Codex, OpenCode, Probe, and owned computer-execution paths.",

        "owner": "OpenAgents agent infrastructure",

        "reconsideration_trigger": "Copilot exposes the lifecycle, evidence, and recovery contracts required by the fleet.",

        "decision_record": "https://openagents.com/OpenAgentsInc/openagents.com/issues/93"

      },

      "history": [

        {

          "state": "deferred",

          "decision_date": "2026-08-23",

          "evidence": [

            {

              "source": "docs/episode-triage.md",

              "summary": "The active fleet uses controllable harnesses with explicit execution and receipt contracts."

            }

          ],

          "violated_principle": "Executor targets must expose controllable lifecycle, evidence, and recovery contracts.",