plan_driven 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cad74cf1d61e2bc83cc71e30037048a81a0042a25a355695e97f1ec5ebdd823
-  data.tar.gz: f9b7139fbc8cac5475fd0b1429ebf90d8f06884c71d49c122b48c310c180c442
+  metadata.gz: 7ffc191c08d6787d03cfccdcb13fb559e2fb48f5d042fbe5597335544f36339f
+  data.tar.gz: f32edb2f3c5cd3fd1eed677bc834d6a60527c59d15d49a89065083dc07ee18b8
 SHA512:
-  metadata.gz: 4b1de072864c1a701b49cff10ff0fa25cbe1c8c111c354884dcaaec308637ed1b62f2a12db0dac5be768f77706d9a03cbd24498cfdc93cd10d07611250ee266b
-  data.tar.gz: 65eb69253b06990105156e72f2a61a9b8b77e7b39b444414ce4516d065ae5a1eabcd0b2a671e1fd33a2929d86031688d8967f3a4d3a97246bac5ca97b3741641
+  metadata.gz: 8a9a83308065071c48d13c575f06966a99fd517a3f6e2fbcacb5d804f937e433395305aef7578332fc171929c8e234923f5abc537ba21e5c6100cbb9e7ee7279
+  data.tar.gz: 79a273ff6f7d84e371445047646f9ea799a374ca0f2a838863b76eb3e9cf3a3a3ded7054235e68c3d500ef02f31e744bf2aa9e255364d071afc0112ed1c9af20

data/CHANGELOG.md

@@ -6,6 +6,25 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+### Added
+
+- Statistics, computed from the audit trail: how long planning, tickets, development and proof
+  took, each ticket's time split into queued, agent coding, waiting for review, agent fixing
+  feedback and approved but not merged, the agents' share of the work, first-time approvals,
+  and acceptance criteria merged and proven over time. `plan-driven stats PLAN` prints them,
+  the wizard has a Statistics page with charts, and the delivery report has a Statistics
+  section.
+- Charts drawn in Ruby as SVG, with no JavaScript: a burn-up of criteria merged and proven,
+  a timeline of each ticket, the split between agents and people, and a bar of every
+  criterion's result. The delivery report writes them next to the Markdown, so GitHub shows
+  them, and inlines them in the HTML and the PDF.
+
+### Changed
+
+- The delivery report has colour: every acceptance criterion's result is a green, red, amber
+  or grey pill with a matching edge on its row, failed rows are tinted red, merged tickets are
+  marked green, and the Markdown shows ✅, ❌, ⏸️ or ⚠️ before each result.
+
 ## [0.2.0] - 2026-09-30
 
 ### Added

data/README.md

@@ -6,11 +6,16 @@
 [![Ruby](https://img.shields.io/badge/Ruby-3.1%20to%203.4-CC342D.svg)](#rails-and-ruby-support)
 [![Rails](https://img.shields.io/badge/Rails-7.0%20to%208.1-D30001.svg)](#rails-and-ruby-support)
 
-**From implementation plan to merged, tested pull requests, driven from the terminal.**
+**From implementation plan to merged, tested pull requests, driven from the browser or the terminal.**
 
-`plan_driven` runs a Rails team's delivery process from the command line, with AI agents doing
-the writing and your team making the decisions. A short interview in the terminal becomes an
-implementation plan grounded in your real schema and code. Guards written in Ruby check the
+`plan_driven` runs a Rails team's delivery process inside your Rails app, with AI agents doing
+the writing and your team making the decisions. Drive it the way you prefer: click through the
+[wizard in the browser](#the-browser-wizard), mounted at `/plan_driven` in development, or type
+the same steps in the [terminal](#commands). Every button in the wizard runs one `plan-driven`
+command and shows it to you, so both are the same process, with the same rules and the same
+audit trail, and you can switch between them at any step.
+
+A short interview becomes an implementation plan grounded in your real schema and code. Guards written in Ruby check the
 plan, you read it and approve it. The approved plan becomes tickets, each ticket goes to a
 Cursor cloud agent that opens a pull request, and only the pull requests you approve are
 merged. Acceptance criteria map to Cucumber scenarios, so the delivery report shows which
@@ -115,6 +120,7 @@ repository. The planner and the five agents ran on Claude Opus 5.5 through Curso
 - [Configuration](#configuration)
 - [Choosing the coding agents](#choosing-the-coding-agents)
 - [Tokens and cost](#tokens-and-cost)
+- [Statistics](#statistics)
 - [How it compares](#how-it-compares)
 - [Keys](#keys)
 - [Working as a team](#working-as-a-team)
@@ -717,8 +723,9 @@ $ bin/plan-driven report PD-1
 
 `evidence` runs the plan's scenarios on your machine and stores the result with the commit it
 ran on; `--from cucumber.json` imports a run from CI instead. The delivery report lists each
-ticket with its pull request, merge commit and approver, then every acceptance criterion with
-the scenario that proves it, the guard findings, every approval and the full timeline. Commit
+ticket with its pull request, merge commit and approver, the [statistics](#statistics) with
+their charts, then every acceptance criterion with the scenario that proves it, marked passed
+or failed in colour, the guard findings, every approval and the full timeline. Commit
 `docs/plans/` with it, and the plan and its proof stay next to the code.
 
 ![The delivery report](docs/images/15-delivery-report.png)
@@ -840,6 +847,7 @@ key such as `PD-1`, and `PLAN/TICKET` is a ticket such as `PD-1/T3`.
 | `report PLAN` | Write the delivery report |
 | `log PLAN` | The audit trail |
 | `usage PLAN` | Tokens, time and cost per step and per agent run |
+| `stats PLAN` | Where the time went: phases, agents and people, each ticket |
 | `questions` | The interview's questions, and which ones the team changed or added |
 | `question KEY [--title T] [--ask Q] [--group G] [--required \| --optional] [--remove]` | Change or add an interview question, or put it back |
 | `configure` | Store keys in `~/.plan_driven/config` |
@@ -985,6 +993,90 @@ For scale, these are the five cloud agents from the demo, read back from Cursor'
 are code and text the agents wrote. Most of an agent's tokens go into reading the codebase, so
 a small, conventional one is cheaper to work on.
 
+## Statistics
+
+Where did the time go? Was it the agents writing code, or the pull requests waiting for a
+person? The same numbers are in three places:
+
+- **In the wizard:** every plan has a Statistics page, linked under its title and from the
+  Proof & report step. In development that's `http://localhost:3000/plan_driven/plans/PD-1/statistics`.
+- **In the terminal:** `bin/plan-driven stats PD-1`.
+- **In the delivery report:** a Statistics section with the same charts, in the Markdown, the
+  HTML and the PDF.
+
+![The Statistics page in the wizard, for a delivered plan](docs/images/statistics.png)
+
+This is PD-3 from the demo: six tickets delivered in 1 h 20 min, 42 of 42 criteria proven.
+
+- **Cards:** idea to delivery, development time, criteria proven, pull requests approved the
+  first time, the agents' share of the work, and tokens.
+- **Acceptance criteria, merged and proven:** a burn-up against the plan's scope. The blue
+  line rises as each ticket merges with its criteria, and the green line rises when an
+  evidence run proves them. Every run is a dot, red when it failed. Here, two runs failed
+  around 14:50 and the third proved all 42.
+- **Where the time went, ticket by ticket:** one row per ticket on a shared clock. Grey is
+  queued, waiting for the tickets it depends on. Blue is an agent coding, amber is the pull
+  request waiting for review, purple is an agent fixing feedback, and green is approved but
+  not merged. T3 has one round of feedback, and each ticket waited for the one before it.
+- **Agents and people:** how the time tickets were worked on splits. Here agents took 91% of
+  it and reviews took 7%. On a plan where the donut is mostly amber, the bottleneck is review,
+  not code.
+- **Ticket by ticket, and the phases:** the same times as a table, with the estimate and the
+  review rounds, and how long planning, tickets, development and proof took.
+
+```
+$ bin/plan-driven stats PD-3
+PD-3 Comments on events: statistics
+  Planning              2 min
+  Tickets               2 min
+  Development           1 h 20 min
+  Proof                 10 min
+  Idea to delivery      1 h 25 min
+  Tickets merged        6 of 6, 5 approved the first time
+✓ 42 of 42 acceptance criteria proven
+
+Where the time went while tickets were worked on (agents 91%):
+  Agent coding           1 h 2 min  ████████████████████ 79%
+  Waiting for review         5 min  ██ 7%
+  Agent fixing feedback      9 min  ███ 12%
+  Approved, not merged       1 min  █ 2%
+
+#   Est  Queued      Agent   Review  Fixes  Merge  Rounds  Total
+T1  2    53s         10 min  4 min   -      23s    0       16 min
+T2  2    17 min      10 min  8s      -      12s    0       10 min
+T3  3    28 min      11 min  28s     9 min  10s    1       21 min
+...
+```
+
+### How it's worked out
+
+Nothing is estimated, and no model is asked. Every number is the time between two events that
+plan-driven already records in the audit trail:
+
+| From | To | Counts as |
+| --- | --- | --- |
+| `tickets.approved` | `ticket.agent_started` | Queued |
+| `ticket.agent_started` | `ticket.pr_opened` | Agent coding |
+| `ticket.pr_opened` | `ticket.pr_approved` or `ticket.changes_requested` | Waiting for review |
+| `ticket.changes_requested` | the next `ticket.pr_opened` | Agent fixing feedback |
+| `ticket.pr_approved` | `ticket.merged` | Approved, not merged |
+
+The phases run from `plan.drafted` to the last `plan.approved` (planning), then to
+`tickets.approved` (tickets), then to `plan.delivered` (development), then to the first
+passing evidence run (proof). A plan still in development is counted up to now. A plan whose
+tickets aren't approved yet shows only its planning time.
+
+The charts are SVG drawn in Ruby, with no JavaScript and nothing to install. `report` writes
+them next to `delivery-report.md` (`statistics-burnup.svg`, `statistics-timeline.svg`,
+`statistics-time.svg`, `statistics-proof.svg`), so GitHub shows them in the Markdown, and it
+inlines them in the HTML and the PDF so both stand alone.
+
+The report also marks every acceptance criterion's result in colour: a green, red, amber or
+grey pill with a matching edge on its row, and failed rows tinted red. On GitHub, the Markdown
+shows ✅, ❌, ⏸️ or ⚠️ instead.
+
+![Acceptance criteria and proof in the delivery report](docs/images/statistics-report.png)
+
 ## How it compares
 
 plan_driven sits next to spec-driven tools such as GitHub's Spec Kit and Kiro, which also start

data/app/controllers/plan_driven/wizard/plans_controller.rb

@@ -6,7 +6,7 @@ module PlanDriven
   module Wizard
     # Every form posts here, and every post becomes one `plan-driven` command. The pages only read.
     class PlansController < ApplicationController
-      before_action :find_plan, only: %i[show run file]
+      before_action :find_plan, only: %i[show statistics run file]
 
       def index
         @plans = Plan.order(id: :desc)
@@ -33,12 +33,16 @@ module PlanDriven
         @template = PlanDriven.configuration.template
       end
 
+      def statistics
+        @step = "statistics"
+        @stats = Statistics.new(@plan)
+      end
+
       def run
         job = start(Commands.argv(params[:do], command_fields))
-        redirect_to plan_path(@plan.key, params[:step].presence, job: job.id, open: params[:open].presence,
-                                                                 anchor: params[:open].presence)
+        redirect_to after_run(job)
       rescue ArgumentError => e
-        redirect_to plan_path(@plan.key, params[:step].presence), alert: e.message
+        redirect_to plan_path(@plan.key, params[:step].presence.presence_in(Steps.keys)), alert: e.message
       end
 
       def run_global
@@ -62,6 +66,13 @@ module PlanDriven
 
       private
 
+      def after_run(job)
+        return plan_statistics_path(@plan.key, job: job.id) if params[:step] == "statistics"
+
+        plan_path(@plan.key, params[:step].presence, job: job.id, open: params[:open].presence,
+                                                     anchor: params[:open].presence)
+      end
+
       def find_plan
         @plan = Plan.find_by_reference!(params[:key])
       rescue ActiveRecord::RecordNotFound => e

data/app/views/layouts/plan_driven/wizard/application.html.erb

@@ -64,6 +64,18 @@
     .grid2 { display:grid; grid-template-columns:minmax(0, 1fr) minmax(0, 2fr); gap:12px; }
     label.check { display:inline-flex; gap:6px; align-items:center; font-weight:400; margin:0; }
     .card.unused { opacity:.75; }
+    .kpis { display:grid; grid-template-columns:repeat(auto-fill, minmax(170px, 1fr)); gap:10px; margin:16px 0 4px; }
+    .kpi { background:#fff; border:1px solid var(--line); border-top:3px solid #3b82f6; border-radius:10px; padding:12px 14px; display:flex; flex-direction:column; gap:2px; }
+    .kpi small { color:var(--muted); font-size:12px; text-transform:uppercase; letter-spacing:.04em; }
+    .kpi strong { font-size:26px; line-height:1.15; } .kpi strong span { font-size:16px; color:var(--muted); font-weight:500; }
+    .kpi .muted { font-size:12px; }
+    .kpi.good { border-top-color:var(--ok); } .kpi.good strong { color:var(--ok); }
+    .kpi.bad { border-top-color:var(--bad); } .kpi.bad strong { color:var(--bad); }
+    .card.chart { padding:6px; } .card.chart svg { display:block; width:100%; height:auto; }
+    .swatch { display:inline-block; width:8px; height:8px; border-radius:2px; margin-right:6px; vertical-align:middle; }
+    .phases { display:flex; gap:0; border-radius:8px; overflow:hidden; border:1px solid var(--line); }
+    .phases div { flex:1; padding:10px 12px; border-right:1px solid var(--line); display:flex; flex-direction:column; }
+    .phases div:last-child { border-right:0; } .phases small { color:var(--muted); } .phases .pending { background:#f9fafb; color:var(--muted); }
     .flash { padding:10px 14px; border-radius:8px; margin-bottom:12px; background:#fee2e2; color:var(--bad); }
   </style>
 </head>

data/app/views/plan_driven/wizard/plans/_finish.html.erb

@@ -15,6 +15,13 @@
   </div>
 <% end %>
 
+<div class="card row">
+  <strong>Statistics</strong>
+  <span class="muted">Where the time went, criteria merged and proven, agents and people.</span>
+  <span style="margin-left:auto"></span>
+  <%= link_to "Open the statistics →", plan_statistics_path(@plan.key), class: "button" %>
+</div>
+
 <% files = %w[delivery-report.html delivery-report.pdf].select { |name| PlanDriven::Renderer.directory(@plan).join(name).file? } %>
 <% if files.any? %>
   <div class="card">

data/app/views/plan_driven/wizard/plans/show.html.erb

@@ -4,6 +4,7 @@
 <p class="muted" style="margin:0">
   <span class="pill <%= @plan.status == "delivered" ? "good" : "wait" %>"><%= @plan.status.tr("_", " ") %></span>
   revision <%= @plan.revision %> · <%= PlanDriven::Workflow::PLAN_DESCRIPTIONS[@plan.status] %>
+  · <%= link_to "Statistics", plan_statistics_path(@plan.key) %>
 </p>
 
 <ol class="steps">

data/app/views/plan_driven/wizard/plans/statistics.html.erb

@@ -0,0 +1,94 @@
+<% content_for :title, "#{@plan.key} statistics" %>
+<% duration = ->(seconds) { PlanDriven::Statistics.duration(seconds) } %>
+<p class="muted" style="margin:0"><%= link_to "← #{@plan.key} #{@plan.title}", plan_path(@plan.key) %></p>
+<h1>Statistics</h1>
+<p class="muted" style="margin:0">
+  <span class="pill <%= @plan.status == "delivered" ? "good" : "wait" %>"><%= @plan.status.tr("_", " ") %></span>
+  Computed from the audit trail: every number is a recorded event, nothing is estimated.
+</p>
+
+<% if @stats.started? %>
+  <% s = @stats.summary %>
+  <div class="kpis">
+    <div class="kpi">
+      <small>Idea to delivery</small>
+      <strong><%= duration[s[:lead_time]] %></strong>
+      <span class="muted"><%= @plan.status == "delivered" ? "plan drafted to delivered" : "so far" %></span>
+    </div>
+    <div class="kpi">
+      <small>Development</small>
+      <strong><%= duration[s[:development]] %></strong>
+      <span class="muted"><%= s[:merged] %> of <%= s[:tickets] %> tickets merged</span>
+    </div>
+    <div class="kpi <%= s[:proven] == s[:criteria] && s[:criteria].positive? ? "good" : (s[:evidence] ? "bad" : "") %>">
+      <small>Criteria proven</small>
+      <strong><%= s[:proven] %> <span>/ <%= s[:criteria] %></span></strong>
+      <span class="muted"><%= s[:evidence] ? "by a passing scenario" : "no evidence run yet" %></span>
+    </div>
+    <div class="kpi">
+      <small>Approved the first time</small>
+      <strong><%= s[:first_time] %> <span>/ <%= s[:merged] %></span></strong>
+      <span class="muted"><%= pluralize(s[:review_rounds], "review round") %></span>
+    </div>
+    <div class="kpi">
+      <small>Agents' share of the work</small>
+      <strong><%= s[:agent_share] ? "#{s[:agent_share]}%" : "-" %></strong>
+      <span class="muted">the rest is waiting on people</span>
+    </div>
+    <div class="kpi">
+      <small>Tokens</small>
+      <strong><%= PlanDriven::Usage.format_tokens(s[:tokens]) %></strong>
+      <span class="muted"><%= s[:cost] ? PlanDriven::Usage.format_cost(s[:cost]) : "set config.token_prices for dollars" %></span>
+    </div>
+  </div>
+
+  <% charts = PlanDriven::Charts.report(@plan, stats: @stats) %>
+  <% %w[statistics-proof.svg statistics-burnup.svg statistics-timeline.svg statistics-time.svg].each do |name| %>
+    <% next unless charts[name] %>
+    <div class="card chart"><%= charts[name].html_safe %></div>
+  <% end %>
+
+  <div class="card">
+    <h3 style="margin-top:0">Ticket by ticket</h3>
+    <table>
+      <thead>
+        <tr><th>#</th><th>Ticket</th><th>Est.</th><th>Queued</th><th>Agent</th><th>Review</th><th>Fixes</th><th>Merge</th><th>Rounds</th><th>Start to merge</th></tr>
+      </thead>
+      <tbody>
+        <% @stats.tickets.each do |row| %>
+          <tr>
+            <td><b><%= row.ticket.key %></b></td>
+            <td><%= row.ticket.title %></td>
+            <td><%= row.ticket.estimate %></td>
+            <% %w[queued agent review fixes merge].each do |phase| %>
+              <td><span class="swatch" style="background:<%= PlanDriven::Charts::COLORS[phase] %>"></span><%= row.seconds(phase).positive? ? duration[row.seconds(phase)] : "-" %></td>
+            <% end %>
+            <td><%= row.review_rounds %></td>
+            <td><% if row.merged? %><span class="pill good"><%= duration[row.cycle_time] %></span><% else %><span class="pill wait"><%= row.ticket.status.tr("_", " ") %></span><% end %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+<% else %>
+  <div class="card">
+    <strong>Statistics start when the tickets are approved.</strong>
+    <p class="muted">Until then, this is how long planning has taken.</p>
+  </div>
+<% end %>
+
+<div class="card">
+  <h3 style="margin-top:0">Phases</h3>
+  <div class="phases">
+    <% @stats.phases.each do |label, seconds| %>
+      <div class="<%= "pending" unless seconds %>"><small><%= label %></small><b><%= seconds ? duration[seconds] : "not yet" %></b></div>
+    <% end %>
+  </div>
+</div>
+
+<div class="card row">
+  <span class="muted">The same numbers in the terminal, and the charts in the delivery report.</span>
+  <span style="margin-left:auto"></span>
+  <%= run_button "Print in the terminal", "stats" %>
+  <%= run_button "Write the delivery report", "report", {}, primary: true %>
+</div>

data/config/routes.rb

@@ -3,6 +3,7 @@
 PlanDriven::Wizard::Engine.routes.draw do
   root "plans#index"
   resources :plans, only: %i[new create], param: :key
+  get "plans/:key/statistics", to: "plans#statistics", as: :plan_statistics
   get "plans/:key(/:step)", to: "plans#show", as: :plan, constraints: { step: /plan|approve|tickets|agents|finish/ }
   post "plans/:key/run", to: "plans#run", as: :run_plan
   get "plans/:key/files/:name", to: "plans#file", as: :plan_file, constraints: { name: /[a-z-]+\.(pdf|html)/ }

data/lib/plan_driven/charts.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module PlanDriven
+  # A plan's statistics as SVG, drawn in Ruby. The same file shows in the wizard, on GitHub next
+  # to the delivery report and in its PDF: no JavaScript, nothing to install.
+  module Charts
+    COLORS = {
+      "queued" => "#d1d5db", "agent" => "#3b82f6", "review" => "#f59e0b", "fixes" => "#8b5cf6",
+      "merge" => "#10b981", "passed" => "#16a34a", "failed" => "#dc2626", "not run" => "#f59e0b",
+      "no scenario" => "#9ca3af"
+    }.freeze
+    INK = "#1f2330"
+    MUTED = "#6b7280"
+    GRID = "#eef0f3"
+    FONT = "-apple-system, 'Segoe UI', Helvetica, Arial, sans-serif"
+    TICKS = [60, 300, 600, 900, 1800, 3600, 7200, 10_800, 21_600, 43_200, 86_400, 172_800, 604_800].freeze
+    STATUSES = ["passed", "failed", "not run", "no scenario"].freeze
+
+    # The report's charts by file name, leaving out any the plan has no data for yet.
+    def self.report(plan, stats: Statistics.new(plan))
+      { "statistics-proof.svg" => proof(Evidence.matrix(plan)), "statistics-burnup.svg" => burnup(stats),
+        "statistics-timeline.svg" => timeline(stats), "statistics-time.svg" => breakdown(stats) }.compact
+    end
+
+    module_function
+
+    # Criteria merged (blue) and proven by a passing test (green), against the plan's scope.
+    def burnup(stats)
+      data = stats.burnup or return
+      width = 760
+      height = 320
+      box = { left: 44, right: 24, top: 84, bottom: 36 }
+      x = scale_time(data[:from], data[:to], box[:left], width - box[:right])
+      top = [data[:scope], 1].max
+      y = ->(value) { box[:top] + ((1 - (value.to_f / top)) * (height - box[:top] - box[:bottom])) }
+      parts = [heading("Acceptance criteria, merged and proven", "#{data[:scope]} in scope")]
+      parts << legend([["Merged", COLORS["agent"]], ["Proven by a passing test", COLORS["passed"]],
+                       ["Scope", MUTED]], 20, 70)
+      parts << value_grid(top, y, box[:left], width - box[:right])
+      parts << time_axis(data[:from], data[:to], x, height - box[:bottom], box[:top])
+      parts << (%(<line x1="#{box[:left]}" x2="#{width - box[:right]}" y1="#{f(y[data[:scope]])}" ) +
+               %(y2="#{f(y[data[:scope]])}" stroke="#{MUTED}" stroke-width="1.5" stroke-dasharray="5 4"/>))
+      parts << step_series(data[:merged], data[:to], x, y, COLORS["agent"], fill: true)
+      parts << step_series(data[:proven], data[:to], x, y, COLORS["passed"])
+      parts << run_dots(data[:proven].drop(1), x, y)
+      svg(width, height, parts.join("\n"), title: "Acceptance criteria merged and proven over time")
+    end
+
+    # One row per ticket on a shared clock: queued, agent coding, waiting for review, fixing
+    # feedback, approved but not merged.
+    def timeline(stats)
+      rows = stats.tickets.select { |row| row.segments.any? }
+      return if rows.empty?
+
+      from, to = stats.window
+      width = 760
+      box = { left: 190, right: 100, top: 84, bottom: 36 }
+      row_height = 30
+      height = box[:top] + (rows.size * row_height) + box[:bottom]
+      x = scale_time(from, to, box[:left], width - box[:right])
+      phases = Statistics::PHASES.select { |phase, _| rows.any? { |row| row.seconds(phase).positive? } }
+      parts = [heading("Where the time went, ticket by ticket", "#{Statistics.duration(to - from)} in development")]
+      parts << legend(phases.map { |phase, label| [label, COLORS[phase]] }, 20, 70)
+      parts << time_axis(from, to, x, height - box[:bottom], box[:top])
+      rows.each_with_index do |row, index|
+        parts << ticket_row(row, box[:top] + (index * row_height), x, box[:left])
+      end
+      svg(width, height, parts.join("\n"), title: "Where the time went, ticket by ticket")
+    end
+
+    # How the time tickets were worked on splits between agents and people.
+    def breakdown(stats)
+      totals = stats.totals.slice(*Statistics::WORK).select { |_, seconds| seconds.positive? }
+      sum = totals.values.sum
+      return if sum.zero?
+
+      width = 760
+      height = 250
+      center = [130, 150]
+      radius = 72
+      circumference = 2 * Math::PI * radius
+      offset = 0.0
+      rings = totals.map do |phase, seconds|
+        length = circumference * seconds / sum
+        ring = %(<circle cx="#{center[0]}" cy="#{center[1]}" r="#{radius}" fill="none" stroke="#{COLORS[phase]}" ) +
+               %(stroke-width="28" stroke-dasharray="#{f(length)} #{f(circumference - length)}" ) +
+               %(stroke-dashoffset="#{f(-offset)}" transform="rotate(-90 #{center[0]} #{center[1]})">) +
+               %(<title>#{esc(Statistics::PHASES[phase])}: #{Statistics.duration(seconds)}</title></circle>)
+        offset += length
+        ring
+      end
+      share = stats.agent_share
+      parts = [heading("Agents and people", "while tickets were being worked on")]
+      parts += rings
+      parts << (%(<text x="#{center[0]}" y="#{center[1] + 2}" text-anchor="middle" font-size="26" ) +
+               %(font-weight="700" fill="#{INK}">#{share}%</text>))
+      parts << %(<text x="#{center[0]}" y="#{center[1] + 22}" text-anchor="middle" fill="#{MUTED}">agents</text>)
+      totals.each_with_index do |(phase, seconds), index|
+        top = 100 + (index * 30)
+        percent = (seconds * 100.0 / sum).round
+        parts << %(<rect x="260" y="#{top - 11}" width="14" height="14" rx="3" fill="#{COLORS[phase]}"/>)
+        parts << %(<text x="284" y="#{top}" fill="#{INK}" font-size="13">#{esc(Statistics::PHASES[phase])}</text>)
+        parts << (%(<text x="560" y="#{top}" fill="#{INK}" font-size="13" text-anchor="end" ) +
+                 %(font-weight="600">#{Statistics.duration(seconds)}</text>))
+        parts << %(<text x="620" y="#{top}" fill="#{MUTED}" font-size="13" text-anchor="end">#{percent}%</text>)
+      end
+      svg(width, height, parts.join("\n"), title: "Time split between agents and people")
+    end
+
+    # Every acceptance criterion's result in one bar.
+    def proof(rows)
+      return if rows.empty?
+
+      width = 760
+      height = 104
+      counts = STATUSES.to_h { |status| [status, rows.count { |row| row.status == status }] }
+      passed = counts["passed"]
+      color = if passed == rows.size then COLORS["passed"]
+              elsif counts["failed"].positive? then COLORS["failed"]
+              else INK
+              end
+      parts = [%(<text x="20" y="34" font-size="17" font-weight="700" fill="#{color}">) +
+        %(#{passed} of #{rows.size} acceptance criteria proven</text>)]
+      left = 20.0
+      span = width - 40.0
+      parts << %(<clipPath id="proof-bar"><rect x="20" y="48" width="#{span}" height="16" rx="8"/></clipPath>)
+      segments = counts.filter_map do |status, count|
+        next if count.zero?
+
+        length = span * count / rows.size
+        bar = %(<rect x="#{f(left)}" y="48" width="#{f(length)}" height="16" fill="#{COLORS[status]}">) +
+              %(<title>#{count} #{status}</title></rect>)
+        left += length
+        bar
+      end
+      parts << %(<g clip-path="url(#proof-bar)">#{segments.join}</g>)
+      shown = counts.reject { |_, count| count.zero? }
+      parts << legend(shown.map { |status, count| ["#{count} #{status}", COLORS[status]] }, 20, 90)
+      svg(width, height, parts.join("\n"), title: "#{passed} of #{rows.size} acceptance criteria proven")
+    end
+
+    def svg(width, height, body, title:)
+      <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{width} #{height}" width="#{width}" height="#{height}" role="img" font-family="#{FONT}" font-size="12">
+        <title>#{esc(title)}</title>
+        <rect width="#{width}" height="#{height}" rx="10" fill="#ffffff"/>
+        #{body}
+        </svg>
+      SVG
+    end
+
+    def heading(text, note)
+      %(<text x="20" y="28" font-size="15" font-weight="700" fill="#{INK}">#{esc(text)}</text>) +
+        %(<text x="20" y="46" fill="#{MUTED}">#{esc(note)}</text>)
+    end
+
+    def legend(items, left, top)
+      x = left
+      items.map do |label, color|
+        item = %(<rect x="#{f(x)}" y="#{top - 10}" width="12" height="12" rx="3" fill="#{color}"/>) +
+               %(<text x="#{f(x + 18)}" y="#{top}" fill="#{MUTED}">#{esc(label)}</text>)
+        x += (label.length * 6.6) + 40
+        item
+      end.join
+    end
+
+    def scale_time(from, to, left, right)
+      start = from.to_f
+      length = [to.to_f - start, 1].max
+      ->(time) { left + ((time.to_f - start) / length * (right - left)) }
+    end
+
+    # Round values up the axis: 0, 10, 20, 30, 40 rather than 0, 11, 21, 32, 42.
+    def value_grid(top, y, left, right)
+      step = [1, 2, 5, 10, 20, 25, 50, 100, 200, 500].find { |size| top / size <= 5 } || (top / 5.0).ceil
+      (0..top).step(step).map do |value|
+        %(<line x1="#{left}" x2="#{right}" y1="#{f(y[value])}" y2="#{f(y[value])}" stroke="#{GRID}"/>) +
+          %(<text x="#{left - 8}" y="#{f(y[value] + 4)}" text-anchor="end" fill="#{MUTED}">#{value}</text>)
+      end.join
+    end
+
+    # Clock ticks at a round interval, labelled in the plan's own time zone.
+    def time_axis(from, to, x, bottom, top)
+      length = to.to_f - from.to_f
+      step = TICKS.find { |seconds| length / seconds <= 7 } || TICKS.last
+      format = step >= 86_400 || length > 86_400 ? "%-d %b" : "%H:%M"
+      first = (from.to_f / step).ceil * step
+      (first..to.to_f).step(step).map do |seconds|
+        time = local(seconds, from)
+        %(<line x1="#{f(x[time])}" x2="#{f(x[time])}" y1="#{top}" y2="#{bottom}" stroke="#{GRID}"/>) +
+          %(<text x="#{f(x[time])}" y="#{bottom + 18}" text-anchor="middle" fill="#{MUTED}">) +
+          %(#{time.strftime(format)}</text>)
+      end.join
+    end
+
+    # A whole number of seconds as a time in the same zone as `like`, without float drift.
+    def local(seconds, like)
+      time = Time.at(seconds)
+      like.respond_to?(:time_zone) ? time.in_time_zone(like.time_zone) : time.getlocal(like.utc_offset)
+    end
+
+    def step_series(points, to, x, y, color, fill: false)
+      path = "M#{f(x[points.first.at])},#{f(y[points.first.value])}"
+      points.drop(1).each { |point| path << " H#{f(x[point.at])} V#{f(y[point.value])}" }
+      path << " H#{f(x[to])}"
+      area = ""
+      area = %(<path d="#{path} V#{f(y[0])} H#{f(x[points.first.at])} Z" fill="#{color}" fill-opacity=".12"/>) if fill
+      %(#{area}<path d="#{path}" fill="none" stroke="#{color}" stroke-width="2.5" stroke-linejoin="round"/>)
+    end
+
+    # One dot per evidence run, red when it failed, with the count on the last one.
+    def run_dots(points, x, y)
+      points.each_with_index.map do |point, index|
+        color = point.status == "passed" ? COLORS["passed"] : COLORS["failed"]
+        label = if index == points.size - 1
+                  %(<text x="#{f(x[point.at] - 8)}" y="#{f(y[point.value] - 10)}" text-anchor="end" ) +
+                    %(font-weight="700" fill="#{color}">#{point.value} proven</text>)
+                end
+        %(<circle cx="#{f(x[point.at])}" cy="#{f(y[point.value])}" r="5" fill="#{color}" stroke="#ffffff" ) +
+          %(stroke-width="2"><title>Evidence #{point.status}: #{point.value} proven</title></circle>#{label})
+      end.join
+    end
+
+    def ticket_row(row, top, x, left)
+      ticket = row.ticket
+      label = "#{ticket.key}  #{ticket.title.to_s.truncate(24)}"
+      bars = row.segments.map do |segment|
+        start = x[segment.from]
+        length = [x[segment.to] - start, 2].max
+        %(<rect x="#{f(start)}" y="#{top + 6}" width="#{f(length)}" height="18" rx="3" ) +
+          %(fill="#{COLORS[segment.phase]}">) +
+          %(<title>#{esc(ticket.key)} · #{esc(Statistics::PHASES[segment.phase])} · ) +
+          %(#{Statistics.duration(segment.seconds)}</title></rect>)
+      end
+      finish = x[row.segments.last.to]
+      total = row.merged? ? Statistics.duration(row.cycle_time) : "open"
+      rounds = row.review_rounds.positive? ? " · #{row.review_rounds} fix" : ""
+      %(<text x="#{left - 12}" y="#{top + 19}" text-anchor="end" fill="#{INK}">#{esc(label)}</text>) +
+        bars.join + %(<text x="#{f(finish + 8)}" y="#{top + 19}" fill="#{MUTED}">#{esc(total + rounds)}</text>)
+    end
+
+    def f(number)
+      number.to_f.round(1).to_s.delete_suffix(".0")
+    end
+
+    def esc(text)
+      CGI.escapeHTML(text.to_s)
+    end
+  end
+end

data/lib/plan_driven/cli/ticket_commands.rb

@@ -143,6 +143,26 @@ module PlanDriven
         ui.muted "No price for #{totals[:unpriced].join(", ")}; set config.token_prices to see dollars."
       end
 
+      def cmd_stats(reference = nil)
+        plan = find_plan(reference)
+        stats = Statistics.new(plan)
+        duration = ->(seconds) { Statistics.duration(seconds) }
+        ui.heading "#{plan.key} #{plan.title}: statistics"
+        stats.phases.each { |label, seconds| ui.say "  #{label.ljust(22)}#{seconds ? duration[seconds] : "not yet"}" }
+        return ui.muted("Ticket statistics start when the tickets are approved.") unless stats.started?
+
+        show_summary(stats.summary)
+        show_time_split(stats)
+        ui.say
+        ui.table(%w[# Est Queued Agent Review Fixes Merge Rounds Total], stats.tickets.map do |row|
+          [row.ticket.key, row.ticket.estimate.to_s,
+           *%w[queued agent review fixes merge].map do |phase|
+             row.seconds(phase).positive? ? duration[row.seconds(phase)] : "-"
+           end,
+           row.review_rounds.to_s, row.merged? ? duration[row.cycle_time] : row.ticket.status.tr("_", " ")]
+        end)
+      end
+
       def cmd_report(reference = nil)
         plan = find_plan(reference)
         paths = delivery.report(plan)
@@ -152,6 +172,27 @@ module PlanDriven
 
       private
 
+      def show_summary(summary)
+        ui.say "  #{"Idea to delivery".ljust(22)}#{Statistics.duration(summary[:lead_time])}"
+        ui.say "  #{"Tickets merged".ljust(22)}#{summary[:merged]} of #{summary[:tickets]}, " \
+               "#{summary[:first_time]} approved the first time"
+        proven = "#{summary[:proven]} of #{summary[:criteria]} acceptance criteria proven"
+        summary[:proven] == summary[:criteria] ? ui.success(proven) : ui.warn(proven)
+      end
+
+      def show_time_split(stats)
+        work = stats.work_seconds
+        return if work.zero?
+
+        ui.say
+        ui.say "Where the time went while tickets were worked on (agents #{stats.agent_share}%):"
+        stats.totals.slice(*Statistics::WORK).each do |phase, seconds|
+          share = seconds * 100.0 / work
+          ui.say "  #{Statistics::PHASES[phase].ljust(22)}#{Statistics.duration(seconds).rjust(10)}  " \
+                 "#{"█" * (share / 4).ceil} #{share.round}%"
+        end
+      end
+
       def explain_waiting(plan)
         running = plan.tickets.count(&:active_agent?)
         if plan.tickets.any?(&:ready?) && running >= PlanDriven.configuration.max_parallel_agents

data/lib/plan_driven/cli.rb

@@ -41,6 +41,7 @@ module PlanDriven
       "report" => ["PLAN", "Write the delivery report"],
       "log" => ["PLAN", "The audit trail"],
       "usage" => ["PLAN", "Tokens and cost per step and per agent run"],
+      "stats" => ["PLAN", "Where the time went: phases, agents and people, each ticket"],
       "questions" => ["", "The interview's questions, with the team's changes"],
       "question" => ["KEY", "Change or add a question (--title, --ask, --group, --required, --optional, --remove)"],
       "configure" => ["", "Store API keys in ~/.plan_driven/config"],

data/lib/plan_driven/evidence.rb

@@ -21,6 +21,9 @@ module PlanDriven
     # when plan-driven itself was started from a development server (the wizard).
     CUCUMBER_ENV = { "RAILS_ENV" => "test", "RACK_ENV" => "test" }.freeze
 
+    # Shown before each result in the Markdown report, so it reads at a glance on GitHub too.
+    MARKS = { "passed" => "✅", "failed" => "❌", "not run" => "⏸️", "no scenario" => "⚠️" }.freeze
+
     module_function
 
     def tag_expression(plan)
@@ -76,8 +79,8 @@ module PlanDriven
       "not run"
     end
 
-    def matrix(plan)
-      scenarios = plan.evidence_runs.last&.scenarios || []
+    def matrix(plan, run = plan.evidence_runs.last)
+      scenarios = run&.scenarios || []
       plan.tickets.flat_map do |ticket|
         ticket.criteria.each_with_index.map do |criterion, index|
           matching = scenarios.select do |scenario|
@@ -94,7 +97,7 @@ module PlanDriven
 
       rows = matrix(plan).map do |row|
         scenario = row.scenarios.map { |s| "#{s["name"]} (`#{s["file"]}`)" }.join("; ").presence || "-"
-        ["#{row.ticket.key}.#{row.number}", row.criterion, scenario, row.status]
+        ["#{row.ticket.key}.#{row.number}", row.criterion, scenario, "#{MARKS[row.status]} #{row.status}"]
       end
       commit = run.commit_sha.present? ? " on commit `#{run.commit_sha[0, 7]}`" : ""
       intro = "Cucumber, run #{run.created_at.strftime("%-d %b %Y %H:%M")}#{commit}: `#{run.command}`"

data/lib/plan_driven/renderer/html.rb

@@ -7,10 +7,14 @@ module PlanDriven
     # and doesn't need to be.
     module HTML
       STYLE = File.read(File.expand_path("style.css", __dir__))
+      IMAGE = /\A!\[([^\]]*)\]\(([^)\s]+)\)\z/
+      # A table cell that is only a result becomes a coloured pill, and colours its row.
+      RESULT = /\A(?:#{Evidence::MARKS.values.map { |mark| Regexp.escape(mark) }.join("|")})?\s*
+                (passed|failed|not\ run|no\ scenario|merged)\z/x
 
       module_function
 
-      def document(markdown, title:)
+      def document(markdown, title:, images: {})
         <<~HTML
           <!doctype html>
           <html lang="en">
@@ -21,19 +25,22 @@ module PlanDriven
           </head>
           <body>
           <main>
-          #{convert(markdown)}
+          #{convert(markdown, images: images)}
           </main>
           </body>
           </html>
         HTML
       end
 
-      def convert(markdown)
+      def convert(markdown, images: {})
         lines = markdown.to_s.lines.map(&:chomp)
         out = []
         until lines.empty?
           line = lines.first
-          if line.start_with?("```")
+          if (image = line.strip.match(IMAGE))
+            lines.shift
+            out << figure(image[1], image[2], images)
+          elsif line.start_with?("```")
             out << code_block(lines)
           elsif line.match?(/\A\s*\|/)
             out << table(take_while(lines) { |l| l.match?(/\A\s*\|/) })
@@ -72,10 +79,32 @@ module PlanDriven
         header, *body = cells
         body = body.reject { |row| row.all? { |cell| cell.match?(/\A:?-+:?\z/) } }
         head = header.map { |cell| "<th>#{inline(cell)}</th>" }.join
-        rows = body.map { |row| "<tr>#{row.map { |cell| "<td>#{inline(cell.gsub("\\|", "|"))}</td>" }.join}</tr>" }
+        rows = body.map { |row| table_row(row) }
         "<table><thead><tr>#{head}</tr></thead><tbody>#{rows.join}</tbody></table>"
       end
 
+      def table_row(row)
+        results = row.filter_map { |cell| cell.match(RESULT)&.[](1) }
+        cells = row.map do |cell|
+          result = cell.match(RESULT)&.[](1)
+          content = if result
+                      %(<span class="result #{result.tr(" ",
+                                                        "-")}">#{result}</span>)
+                    else
+                      inline(cell.gsub("\\|", "|"))
+                    end
+          "<td>#{content}</td>"
+        end
+        klass = results.last ? %( class="#{results.last.tr(" ", "-")}") : ""
+        "<tr#{klass}>#{cells.join}</tr>"
+      end
+
+      # A chart written next to the document is inlined, so the HTML and PDF stand alone.
+      def figure(alt, src, images)
+        body = images[src] || %(<img src="#{CGI.escapeHTML(src)}" alt="#{CGI.escapeHTML(alt)}">)
+        %(<figure class="chart">#{body}</figure>)
+      end
+
       def list(lines)
         ordered = lines.first.match?(/\A\s*\d+\./)
         items = []

data/lib/plan_driven/renderer/markdown.rb

@@ -17,10 +17,12 @@ module PlanDriven
         "#{parts.join("\n\n")}\n"
       end
 
-      def report(plan)
+      # `charts` are the SVG files written next to the report, by name.
+      def report(plan, charts: [])
         parts = ["# #{plan.key}: #{plan.title} (delivery report)", meta(plan)]
-        parts << "## Summary\n\n#{summary(plan)}"
+        parts << "## Summary\n\n#{summary(plan)}#{chart(charts, "statistics-proof.svg", "Acceptance criteria proven")}"
         parts << "## Tickets and pull requests\n\n#{delivery_table(plan)}"
+        parts << "## Statistics\n\n#{statistics(plan, charts)}"
         parts << "## Acceptance criteria and proof\n\n#{Evidence.matrix_markdown(plan)}"
         parts << "## Checks run on each pull request\n\n#{guard_findings(plan)}"
         parts << "## Tokens and cost\n\n#{usage_table(plan)}"
@@ -89,6 +91,43 @@ module PlanDriven
         table(["#", "Ticket", "Status", "Pull request", "Merge commit", "Approved by"], rows)
       end
 
+      def statistics(plan, charts)
+        stats = Statistics.new(plan)
+        return "Statistics start when the tickets are approved." unless stats.started?
+
+        figures = [["statistics-burnup.svg", "Acceptance criteria merged and proven"],
+                   ["statistics-timeline.svg", "Where the time went, ticket by ticket"],
+                   ["statistics-time.svg", "Agents and people"]].map { |name, alt| chart(charts, name, alt) }.join
+        "#{table(%w[Measure Value], statistics_rows(stats))}#{figures}\n\n#{ticket_times(stats)}"
+      end
+
+      def statistics_rows(stats)
+        s = stats.summary
+        duration = ->(seconds) { Statistics.duration(seconds) }
+        rows = stats.phases.filter_map { |label, seconds| ["#{label} time", duration[seconds]] if seconds }
+        rows << ["Idea to delivery", duration[s[:lead_time]]]
+        rows << ["Pull requests approved the first time", "#{s[:first_time]} of #{s[:merged]}"]
+        rows << ["Review rounds (feedback sent to an agent)", s[:review_rounds].to_s]
+        rows << ["Agents' share of the time tickets were worked on", "#{s[:agent_share]}%"] if s[:agent_share]
+        rows << ["Estimated points", s[:points].to_s]
+        rows
+      end
+
+      def ticket_times(stats)
+        duration = ->(seconds) { seconds.positive? ? Statistics.duration(seconds) : "-" }
+        rows = stats.tickets.map do |row|
+          [row.ticket.key, row.ticket.estimate.to_s, duration[row.seconds("queued")], duration[row.seconds("agent")],
+           duration[row.seconds("review")], duration[row.seconds("fixes")], duration[row.seconds("merge")],
+           row.review_rounds.to_s, row.merged? ? Statistics.duration(row.cycle_time) : "open"]
+        end
+        table(["#", "Estimate", "Queued", "Agent coding", "Waiting for review", "Fixing feedback",
+               "Approved, not merged", "Review rounds", "Start to merge"], rows)
+      end
+
+      def chart(charts, name, alt)
+        charts.include?(name) ? "\n\n![#{alt}](#{name})" : ""
+      end
+
       def guard_findings(plan)
         lines = plan.tickets.map do |ticket|
           report = Guards::Report.from_h(ticket.guard_report)

data/lib/plan_driven/renderer/style.css

@@ -20,3 +20,24 @@ th { background: #f6f8fa; font-weight: 600; }
 tr { break-inside: avoid; }
 a { color: #0969da; text-decoration: none; }
 h1, h2, h3 { break-after: avoid; }
+html { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+h2 { color: #1f2330; border-left: 4px solid #cc342d; padding-left: 10px; }
+th { background: #f3f4f6; }
+.result { display: inline-block; padding: 1px 9px; border-radius: 10px; font-size: 8.5pt; font-weight: 600; white-space: nowrap; }
+.result::before { margin-right: 4px; }
+.result.passed, .result.merged { background: #dcfce7; color: #15803d; }
+.result.passed::before, .result.merged::before { content: "✓"; }
+.result.failed { background: #fee2e2; color: #b91c1c; }
+.result.failed::before { content: "✗"; }
+.result.not-run { background: #fef3c7; color: #b45309; }
+.result.not-run::before { content: "•"; }
+.result.no-scenario { background: #f3f4f6; color: #6b7280; }
+.result.no-scenario::before { content: "–"; }
+tr.passed td:first-child { border-left: 3px solid #16a34a; }
+tr.failed td { background: #fef2f2; }
+tr.failed td:first-child { border-left: 3px solid #dc2626; }
+tr.not-run td { background: #fffbeb; }
+tr.not-run td:first-child { border-left: 3px solid #f59e0b; }
+tr.no-scenario td:first-child { border-left: 3px solid #9ca3af; }
+figure.chart { margin: 12px 0 18px; border: 1px solid #e5e7eb; border-radius: 10px; overflow: hidden; break-inside: avoid; }
+figure.chart svg, figure.chart img { display: block; width: 100%; height: auto; }

data/lib/plan_driven/renderer.rb

@@ -17,23 +17,30 @@ module PlanDriven
       write(plan, "plan", Markdown.plan(plan, config: config), title: "#{plan.key} #{plan.title}", config: config)
     end
 
+    # The charts are SVG files beside the report, so GitHub shows them in the Markdown; the HTML
+    # and the PDF carry them inline.
     def write_report(plan, config: PlanDriven.configuration)
-      write(plan, "delivery-report", Markdown.report(plan),
-            title: "#{plan.key} delivery report", config: config)
+      charts = Charts.report(plan)
+      dir = directory(plan, config: config)
+      FileUtils.mkdir_p(dir)
+      Dir[dir.join("statistics-*.svg")].each { |file| File.delete(file) }
+      charts.each { |name, svg| File.write(dir.join(name), svg) }
+      write(plan, "delivery-report", Markdown.report(plan, charts: charts.keys),
+            title: "#{plan.key} delivery report", config: config, images: charts)
     end
 
     def directory(plan, config: PlanDriven.configuration)
       config.docs_root.join(plan.slug)
     end
 
-    def write(plan, name, markdown, title:, config:)
+    def write(plan, name, markdown, title:, config:, images: {})
       dir = directory(plan, config: config)
       FileUtils.mkdir_p(dir)
       md = dir.join("#{name}.md")
       html = dir.join("#{name}.html")
       pdf = dir.join("#{name}.pdf")
       File.write(md, markdown)
-      File.write(html, HTML.document(markdown, title: title))
+      File.write(html, HTML.document(markdown, title: title, images: images))
       written = PDF.render(html, pdf, config: config)
       { markdown: md, html: html, pdf: written ? pdf : nil }
     end

data/lib/plan_driven/statistics.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module PlanDriven
+  # Where a plan's time went, read from its audit trail: when each ticket was queued, when an
+  # agent was writing code, when it waited for a person, and when its acceptance criteria were
+  # merged and then proven. Arithmetic on recorded events, so it gives the same answer every time.
+  class Statistics
+    PHASES = {
+      "queued" => "Queued",
+      "agent" => "Agent coding",
+      "review" => "Waiting for review",
+      "fixes" => "Agent fixing feedback",
+      "merge" => "Approved, not merged"
+    }.freeze
+    WORK = %w[agent review fixes merge].freeze
+    AGENT = %w[agent fixes].freeze
+
+    # Each of these events starts the ticket's next phase; merging ends the last one.
+    NEXT_PHASE = {
+      "ticket.agent_started" => "agent", "ticket.pr_opened" => "review", "ticket.agent_failed" => "review",
+      "ticket.changes_requested" => "fixes", "ticket.pr_approved" => "merge", "ticket.merged" => nil
+    }.freeze
+
+    Segment = Struct.new(:phase, :from, :to) do
+      def seconds = to - from
+    end
+
+    TicketRow = Struct.new(:ticket, :segments, :review_rounds, :merged_at, keyword_init: true) do
+      def seconds(phase = nil)
+        segments.select { |segment| phase.nil? || segment.phase == phase }.sum(&:seconds)
+      end
+
+      def merged? = !merged_at.nil?
+      def first_time? = merged? && review_rounds.zero?
+      def started_at = segments.find { |segment| segment.phase != "queued" }&.from
+      def cycle_time = merged_at && started_at && (merged_at - started_at)
+    end
+
+    Point = Struct.new(:at, :value, :status)
+
+    attr_reader :plan, :now
+
+    def self.duration(seconds)
+      return "-" if seconds.nil?
+
+      seconds = seconds.round
+      return "#{seconds}s" if seconds < 60
+
+      minutes = seconds / 60
+      return "#{minutes} min" if minutes < 60
+
+      hours, minutes = minutes.divmod(60)
+      return "#{hours} h#{" #{minutes} min" if minutes.positive?}" if hours < 24
+
+      days, hours = hours.divmod(24)
+      "#{days} d#{" #{hours} h" if hours.positive?}"
+    end
+
+    def initialize(plan, now: Time.now)
+      @plan = plan
+      @now = now
+      @events = plan.events.includes(:ticket).to_a
+    end
+
+    def started? = !development_start.nil?
+
+    def development_start
+      @development_start ||= (first("tickets.approved") || first("ticket.agent_started"))&.created_at
+    end
+
+    def delivered_at
+      first("plan.delivered")&.created_at
+    end
+
+    # The span the charts draw: from approving the tickets to delivery, or to now while it runs.
+    def window
+      return unless started?
+
+      finish = [delivered_at || now, *plan.evidence_runs.map(&:created_at)].max
+      [development_start, [finish, development_start + 60].max]
+    end
+
+    def tickets
+      @tickets ||= plan.tickets.map { |ticket| ticket_row(ticket) }
+    end
+
+    def totals
+      PHASES.keys.to_h { |phase| [phase, tickets.sum { |row| row.seconds(phase) }] }
+    end
+
+    def work_seconds
+      totals.slice(*WORK).values.sum
+    end
+
+    # The agents' part of the time a ticket was being worked on, from 0 to 100.
+    def agent_share
+      work = work_seconds
+      return if work.zero?
+
+      (totals.slice(*AGENT).values.sum * 100.0 / work).round
+    end
+
+    # Planning phases, first to last, as [label, seconds].
+    def phases
+      drafted = first("plan.drafted")&.created_at
+      approved = last("plan.approved")&.created_at
+      proven = plan.evidence_runs.find(&:passed?)&.created_at
+      [["Planning", span(drafted, approved)], ["Tickets", span(approved, development_start)],
+       ["Development", span(development_start, delivered_at || (now if started?))],
+       ["Proof", span(delivered_at, proven)]]
+    end
+
+    # Criteria merged and criteria proven by a passing test, over time, against the plan's scope.
+    def burnup
+      return unless started?
+
+      { scope: plan.tickets.sum { |ticket| ticket.criteria.size }, from: window.first, to: window.last,
+        merged: merged_points, proven: proven_points }
+    end
+
+    def summary
+      rows = tickets
+      { lead_time: span(first("plan.drafted")&.created_at, delivered_at || now), development: phases[2].last,
+        merged: rows.count(&:merged?), tickets: rows.size, first_time: rows.count(&:first_time?),
+        review_rounds: rows.sum(&:review_rounds), agent_share: agent_share,
+        points: plan.tickets.sum { |ticket| ticket.estimate.to_i } }.merge(proof, usage)
+    end
+
+    private
+
+    def proof
+      matrix = Evidence.matrix(plan)
+      { proven: matrix.count { |row| row.status == "passed" }, criteria: matrix.size,
+        evidence: plan.evidence_runs.any? }
+    end
+
+    def usage
+      totals = Usage.totals(Usage.rows(plan))
+      { tokens: totals[:total_tokens], cost: totals[:cost] }
+    end
+
+    def ticket_row(ticket)
+      events = @events.select { |event| event.ticket_id == ticket.id && NEXT_PHASE.key?(event.name) }
+      TicketRow.new(ticket: ticket, segments: segments(events),
+                    review_rounds: events.count { |event| event.name == "ticket.changes_requested" },
+                    merged_at: events.reverse.find { |event| event.name == "ticket.merged" }&.created_at)
+    end
+
+    # Every ticket is queued from the moment the tickets are approved until its agent starts.
+    def segments(events)
+      return [] unless development_start
+
+      phase = "queued"
+      from = development_start
+      list = events.filter_map do |event|
+        segment = Segment.new(phase, from, event.created_at) if phase && event.created_at > from
+        phase = NEXT_PHASE[event.name]
+        from = [from, event.created_at].max
+        segment
+      end
+      finish = delivered_at || now
+      list << Segment.new(phase, from, finish) if phase && finish > from
+      list
+    end
+
+    def merged_points
+      seen = Set.new
+      count = 0
+      merges = @events.select { |event| event.name == "ticket.merged" && event.ticket && seen.add?(event.ticket_id) }
+      [Point.new(development_start, 0)] + merges.map do |event|
+        count += event.ticket.criteria.size
+        Point.new(event.created_at, count)
+      end
+    end
+
+    def proven_points
+      runs = plan.evidence_runs.to_a
+      [Point.new(development_start, 0)] + runs.map do |run|
+        Point.new(run.created_at, Evidence.matrix(plan, run).count { |row| row.status == "passed" }, run.status)
+      end
+    end
+
+    def first(name)
+      @events.find { |event| event.name == name }
+    end
+
+    def last(name)
+      @events.reverse.find { |event| event.name == name }
+    end
+
+    def span(from, to)
+      from && to && to >= from ? to - from : nil
+    end
+  end
+end

data/lib/plan_driven/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PlanDriven
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/plan_driven/wizard.rb

@@ -14,7 +14,7 @@ module PlanDriven
     # The commands the wizard may run, built from form fields. Nothing else reaches a shell:
     # arguments are passed as an array, never interpolated.
     module Commands
-      PLAN_ONLY = %w[check submit pdf status evidence report usage log].freeze
+      PLAN_ONLY = %w[check submit pdf status evidence report usage stats log].freeze
 
       BUILDERS = {
         "doctor" => ->(_p) { [] },

data/lib/plan_driven.rb

@@ -31,8 +31,10 @@ require_relative "plan_driven/cursor_agents"
 require_relative "plan_driven/local_agents"
 require_relative "plan_driven/usage"
 require_relative "plan_driven/repository"
-require_relative "plan_driven/renderer"
 require_relative "plan_driven/evidence"
+require_relative "plan_driven/statistics"
+require_relative "plan_driven/charts"
+require_relative "plan_driven/renderer"
 require_relative "plan_driven/delivery"
 require_relative "plan_driven/wizard"
 require_relative "plan_driven/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: plan_driven
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ivan Blažević
 bindir: exe
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -50,9 +50,10 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '9'
 description: |
-  plan_driven runs a Rails team's delivery process from the command line. A terminal interview
-  turns an idea into an implementation plan grounded in your real schema; the plan is checked
-  by guards written in Ruby, rendered to PDF and approved. Approved plans become tickets, each
+  plan_driven runs a Rails team's delivery process inside your Rails app, from a browser wizard
+  or the command line: every button in the wizard runs the same plan-driven command. A short
+  interview turns an idea into an implementation plan grounded in your real schema; the plan
+  is checked by guards written in Ruby, rendered to PDF and approved. Approved plans become tickets, each
   ticket is handed to a Cursor cloud agent that opens a pull request, and only pull requests
   you approve are merged. Acceptance criteria map to Cucumber scenarios, and every phase leaves
   documentation behind: the plan, the tickets, the pull requests and a delivery report.
@@ -80,6 +81,7 @@ files:
 - app/views/plan_driven/wizard/plans/index.html.erb
 - app/views/plan_driven/wizard/plans/new.html.erb
 - app/views/plan_driven/wizard/plans/show.html.erb
+- app/views/plan_driven/wizard/plans/statistics.html.erb
 - config/routes.rb
 - exe/plan-driven
 - lib/generators/plan_driven/install_generator.rb
@@ -87,6 +89,7 @@ files:
 - lib/generators/plan_driven/templates/plan_driven.rb
 - lib/plan_driven.rb
 - lib/plan_driven/agent_prompt.rb
+- lib/plan_driven/charts.rb
 - lib/plan_driven/cli.rb
 - lib/plan_driven/cli/config_commands.rb
 - lib/plan_driven/cli/plan_commands.rb
@@ -131,6 +134,7 @@ files:
 - lib/plan_driven/renderer/style.css
 - lib/plan_driven/repository.rb
 - lib/plan_driven/schema_context.rb
+- lib/plan_driven/statistics.rb
 - lib/plan_driven/template.rb
 - lib/plan_driven/ticket_generator.rb
 - lib/plan_driven/usage.rb
@@ -164,5 +168,5 @@ requirements: []
 rubygems_version: 3.6.4
 specification_version: 4
 summary: From implementation plan to merged, tested pull requests, driven from the
-  terminal.
+  browser or the terminal.
 test_files: []