plan_driven 0.1.0 → 0.3.0

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

@@ -0,0 +1,42 @@
+<% can_draft = %w[approved ticketed].include?(@plan.status) %>
+<div class="card">
+  <%= form_with url: run_plan_path(@plan.key), method: :post, class: "row" do %>
+    <%= hidden_field_tag :do, "tickets" %><%= hidden_field_tag :step, "tickets" %>
+    <%= text_field_tag :instruction, nil, placeholder: @plan.tickets.any? ? "what to change, e.g. split T2 into model and UI" : "optional guidance for the tickets",
+                       disabled: !can_draft %>
+    <button type="submit" class="<%= "primary" if @plan.tickets.empty? %>" <%= "disabled" unless can_draft %>>
+      <%= @plan.tickets.any? ? "Redraft tickets" : "Draft tickets" %></button>
+  <% end %>
+</div>
+
+<% if @plan.tickets.any? %>
+  <div class="card">
+    <table>
+      <thead><tr><th>Ticket</th><th>Type</th><th>Est.</th><th>Depends on</th><th>Status</th></tr></thead>
+      <tbody>
+        <% @plan.tickets.each do |ticket| %>
+          <tr>
+            <td><strong><%= ticket.key %></strong> <%= ticket.title %>
+              <details><summary class="muted">acceptance criteria</summary>
+                <ul><% ticket.criteria.each do |criterion| %><li><%= criterion.is_a?(Hash) ? criterion.values.join(" ") : criterion %></li><% end %></ul>
+              </details></td>
+            <td><%= ticket.ticket_type %></td>
+            <td><%= ticket.estimate %></td>
+            <td><%= ticket.dependencies.join(", ").presence || "—" %></td>
+            <td><span class="pill"><%= ticket.status.tr("_", " ") %></span></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+
+  <% if @plan.status == "ticketed" %>
+    <div class="card row">
+      <span>Approvals needed: <strong><%= @plan.missing_ticket_approvals.join(", ").presence || "none" %></strong></span>
+      <span style="margin-left:auto"></span>
+      <% @plan.missing_ticket_approvals.each do |role| %>
+        <%= run_button "Approve tickets as #{role}", "approve-tickets", { role: role }, primary: true %>
+      <% end %>
+    </div>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,31 @@
+<% content_for :title, "plan_driven" %>
+<h1>Implementation plans</h1>
+<p class="muted">From an idea to merged pull requests, one step at a time. Each button runs the same
+  <code>plan-driven</code> command you could type yourself; the panel on the right shows it.</p>
+
+<div class="row">
+  <%= link_to "New plan", new_plan_path, class: "button primary" %>
+  <%= button_to "Check the setup", run_path(do: "doctor"), form: { style: "display:inline" } %>
+</div>
+
+<% if @plans.any? %>
+  <div class="card">
+    <table>
+      <thead><tr><th>Plan</th><th>Title</th><th>Phase</th><th>Revision</th><th>Tickets</th><th></th></tr></thead>
+      <tbody>
+        <% @plans.each do |plan| %>
+          <tr>
+            <td><strong><%= plan.key %></strong></td>
+            <td><%= plan.title %></td>
+            <td><span class="pill <%= plan.status == "delivered" ? "good" : "wait" %>"><%= plan.status.tr("_", " ") %></span></td>
+            <td><%= plan.revision %></td>
+            <td><%= plan.tickets.size %></td>
+            <td><%= link_to "Open", plan_path(plan.key) %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+<% else %>
+  <div class="card muted">No plans yet. Start with “New plan”.</div>
+<% end %>

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

@@ -0,0 +1,21 @@
+<% content_for :title, "New plan" %>
+<h1>New plan</h1>
+<p class="muted">The same questions <code>plan-driven new</code> asks in the terminal. Your answers go to the
+  command as its input; the model drafts the rest from them and your schema, then the guards check it.</p>
+
+<%= form_with url: plans_path, method: :post do |f| %>
+  <label for="title">Title of the change</label>
+  <%= f.text_field :title, value: params[:title], id: "title", required: true %>
+
+  <% @template.asked.each do |section| %>
+    <label for="answer_<%= section.key %>"><%= section.title %>
+      <small><%= section.prompt %></small></label>
+    <%= text_area_tag "answers[#{section.key}]", params.dig(:answers, section.key), id: "answer_#{section.key}",
+                      rows: section.required ? 4 : 2 %>
+  <% end %>
+
+  <div class="nav">
+    <%= link_to "← Back", root_path, class: "button" %>
+    <button type="submit" class="primary">Draft the plan →</button>
+  </div>
+<% end %>

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

@@ -0,0 +1,37 @@
+<% content_for :title, "#{@plan.key} #{@plan.title}" %>
+<p class="muted" style="margin:0"><%= link_to "All plans", root_path %></p>
+<h1><%= @plan.key %> · <%= @plan.title %></h1>
+<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">
+  <% PlanDriven::Wizard::Steps::ORDER.each_with_index do |(key, title, hint), index| %>
+    <li>
+      <% if key == @step %>
+        <span class="here"><b><%= index + 1 %>. <%= title %></b><%= hint %></span>
+      <% elsif PlanDriven::Wizard::Steps.reached?(@plan, key) %>
+        <%= link_to plan_path(@plan.key, key) do %><b><%= index + 1 %>. <%= title %></b><%= hint %><% end %>
+      <% else %>
+        <span><b><%= index + 1 %>. <%= title %></b><%= hint %></span>
+      <% end %>
+    </li>
+  <% end %>
+</ol>
+
+<%= render @step %>
+
+<% keys = PlanDriven::Wizard::Steps.keys; position = keys.index(@step) %>
+<div class="nav">
+  <% if position.zero? %>
+    <%= link_to "← All plans", root_path, class: "button" %>
+  <% else %>
+    <%= link_to "← Back", plan_path(@plan.key, keys[position - 1]), class: "button" %>
+  <% end %>
+  <% if (following = keys[position + 1]) %>
+    <%= link_to "Next →", plan_path(@plan.key, following),
+                class: "button primary #{"disabled" unless PlanDriven::Wizard::Steps.reached?(@plan, following)}" %>
+  <% end %>
+</div>

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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)/ }
+  post "run", to: "plans#run_global", as: :run
+  post "actor", to: "plans#actor", as: :actor
+  get "configuration", to: "configuration#show", as: :configuration
+  post "configuration/question", to: "configuration#question", as: :configuration_question
+  post "configuration/connect", to: "configuration#connect", as: :configuration_connect
+  post "configuration/check", to: "configuration#check", as: :configuration_check
+  get "jobs/:id", to: "jobs#show", as: :job
+end

data/exe/plan-driven

@@ -4,4 +4,5 @@
 require "plan_driven"
 require "plan_driven/cli"
 
+$stdout.sync = true
 exit PlanDriven::CLI.start(ARGV)

data/lib/generators/plan_driven/install_generator.rb

@@ -23,6 +23,10 @@ module PlanDriven
         create_file "docs/plans/.keep"
       end
 
+      def mount_wizard
+        route 'mount PlanDriven::Wizard::Engine, at: "/plan_driven" if Rails.env.development?'
+      end
+
       def show_next_steps
         say <<~TEXT
 
@@ -30,6 +34,9 @@ module PlanDriven
             bin/rails db:migrate
             bundle exec plan-driven configure   # keys for the LLM, Cursor and GitHub
             bundle exec plan-driven new "Short title of the change"
+
+          Or do it all in the browser: start the app and open /plan_driven
+          (development only; every step runs the same plan-driven command).
         TEXT
       end
     end

data/lib/generators/plan_driven/templates/plan_driven.rb

@@ -14,11 +14,17 @@ if defined?(PlanDriven.configure)
     # config.plan_approvals = %w[review qa devops director]
     # config.ticket_approvals = %w[review]
 
-    # Cursor cloud agents: one agent and one pull request per ticket.
+    # Coding agents: one agent and one pull request per ticket. Cursor cloud agents by default,
+    # or a local CLI in its own git worktree per ticket.
     # config.agent_model = "composer-2.5"
+    # config.agent_provider = :local
+    # config.agent_command = "claude -p --permission-mode acceptEdits --output-format json"
     # config.base_branch = "main"
     # config.max_parallel_agents = 3
 
+    # Dollars per million tokens, for the cost in `plan-driven usage` and the delivery report.
+    # config.token_prices = { "your-model-id" => { input: 3.0, output: 15.0, cache_read: 0.3 } }
+
     # GitHub. The repository is read from `git remote get-url origin` when not set.
     # config.github_repository = "your-org/your-app"
     # config.sync_issues = true
@@ -35,5 +41,8 @@ if defined?(PlanDriven.configure)
     #   "Service objects live in app/services and respond to .call.",
     #   "Authorization goes through Pundit policies, never in controllers."
     # ]
+
+    # The browser wizard at /plan_driven: development only by default, local requests always.
+    # config.wizard_enabled = true
   end
 end

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/config_commands.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module PlanDriven
+  class CLI
+    # The interview's questions, and connecting the services with a key that's checked first.
+    module ConfigCommands
+      def cmd_questions
+        config = PlanDriven.configuration
+        ui.table(%w[Key Source Asks], config.template.asked.map do |section|
+          [section.key, Interview.origin(section.key, template: config.base_template), section.prompt]
+        end)
+        ui.muted "Changes are in #{Interview::PATH}; commit it so the team gets the same interview."
+      end
+
+      def cmd_question(key = nil)
+        raise ArgumentError, "Which question? Pass its key, for example who." if key.to_s.empty?
+
+        base = PlanDriven.configuration.base_template
+        if @options[:remove]
+          result = Interview.remove(key, template: base)
+          ui.success(result == :removed ? "Question #{key} removed" : "Question #{key} is back to the default")
+        else
+          result = Interview.change(key, question_fields, template: base)
+          ui.success "Question #{key} #{result}"
+        end
+        cmd_questions
+      end
+
+      def cmd_connect(name = nil)
+        service = Connections.find(name)
+        ui.muted "#{service.title}: #{service.purpose}. Get a key at #{service.url}"
+        value = ui.secret("#{service.title} key:")
+        raise ArgumentError, "No key given; nothing was stored." if value.empty?
+
+        ui.say "Checking the key with #{service.title}..."
+        detail = verify_connection(service, value)
+        path = Credentials.store(service.key, value)
+        ui.success "#{service.title}: #{detail}"
+        ui.muted "  stored in #{path} (0600), never in the app"
+        return if ENV[service.env].to_s.strip.empty?
+
+        ui.warn "#{service.env} is set in this environment, and it wins over the stored key."
+      end
+
+      private
+
+      def question_fields
+        fields = { "title" => @options[:title], "question" => @options[:ask], "group" => @options[:group] }.compact
+        fields["required"] = @options[:required] unless @options[:required].nil?
+        fields
+      end
+
+      def verify_connection(service, value)
+        Connections.verify(service, value)
+      rescue Error => e
+        raise ProviderError, "#{e.message}; nothing was stored."
+      end
+    end
+  end
+end

data/lib/plan_driven/cli/plan_commands.rb

@@ -44,7 +44,11 @@ module PlanDriven
         plan = find_plan(reference)
         section = PlanDriven.configuration.template[key] or
           raise ArgumentError, "Which section? One of: #{PlanDriven.configuration.template.keys.join(", ")}"
-        text = edit_in_editor(plan.section(section.key), "#{plan.key}-#{section.key}")
+        text = if @options[:from]
+                 File.read(@options[:from], encoding: "UTF-8")
+               else
+                 edit_in_editor(plan.section(section.key), "#{plan.key}-#{section.key}")
+               end
         return ui.muted("No change.") if text.strip == plan.section(section.key).strip
 
         delivery.edit_section(plan, section.key, text)
@@ -124,7 +128,7 @@ module PlanDriven
         PlanDriven.configuration.template.asked.to_h do |section|
           answer = ""
           loop do
-            answer = ui.ask_multiline("#{section.title}: #{section.question}")
+            answer = ui.ask_multiline("#{section.title}: #{section.prompt}")
             break unless section.required && answer.strip.empty?
 
             ui.warn "#{section.title} is required."