plan_driven 0.1.0

data/exe/plan-driven

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "plan_driven"
+require "plan_driven/cli"
+
+exit PlanDriven::CLI.start(ARGV)

data/lib/generators/plan_driven/install_generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module PlanDriven
+  module Generators
+    # bin/rails generate plan_driven:install
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_migration
+        migration_template "create_plan_driven_tables.rb.tt", "db/migrate/create_plan_driven_tables.rb"
+      end
+
+      def copy_initializer
+        template "plan_driven.rb", "config/initializers/plan_driven.rb"
+      end
+
+      def create_docs_directory
+        create_file "docs/plans/.keep"
+      end
+
+      def show_next_steps
+        say <<~TEXT
+
+          Next:
+            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"
+        TEXT
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+class CreatePlanDrivenTables < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :plan_driven_plans do |t|
+      t.string :key, null: false
+      t.string :title, null: false
+      t.string :status, null: false, default: "draft"
+      t.integer :revision, null: false, default: 1
+      t.json :interview
+      t.json :sections
+      t.json :guard_report
+      t.string :created_by
+      t.timestamps
+    end
+    add_index :plan_driven_plans, :key, unique: true
+
+    create_table :plan_driven_tickets do |t|
+      t.references :plan, null: false, foreign_key: { to_table: :plan_driven_plans }
+      t.string :key, null: false
+      t.integer :position, null: false, default: 0
+      t.string :title, null: false
+      t.string :kind, null: false, default: "code"
+      t.string :ticket_type, null: false, default: "TASK"
+      t.text :story
+      t.text :description
+      t.json :acceptance_criteria
+      t.text :implementation_notes
+      t.integer :estimate
+      t.json :depends_on
+      t.json :touches
+      t.string :status, null: false, default: "draft"
+      t.integer :issue_number
+      t.string :agent_id
+      t.string :agent_run_id
+      t.string :agent_url
+      t.string :branch
+      t.string :pr_url
+      t.integer :pr_number
+      t.string :merged_sha
+      t.json :guard_report
+      t.timestamps
+    end
+    add_index :plan_driven_tickets, %i[plan_id key], unique: true
+
+    create_table :plan_driven_approvals do |t|
+      t.references :approvable, polymorphic: true, null: false
+      t.string :role, null: false
+      t.string :decision, null: false
+      t.string :actor, null: false
+      t.integer :revision
+      t.text :note
+      t.timestamps
+    end
+
+    create_table :plan_driven_events do |t|
+      t.references :plan, null: false, foreign_key: { to_table: :plan_driven_plans }
+      t.references :ticket, foreign_key: { to_table: :plan_driven_tickets }
+      t.string :name, null: false
+      t.string :actor, null: false
+      t.json :payload
+      t.datetime :created_at, null: false
+    end
+
+    create_table :plan_driven_evidence_runs do |t|
+      t.references :plan, null: false, foreign_key: { to_table: :plan_driven_plans }
+      t.string :kind, null: false
+      t.string :command
+      t.string :status, null: false
+      t.string :commit_sha
+      t.json :results
+      t.datetime :created_at, null: false
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Keys are never set here. They come from the environment or ~/.plan_driven/config,
+# written by `bundle exec plan-driven configure`. The gem is usually in the :development group
+# only, hence the check.
+if defined?(PlanDriven.configure)
+  PlanDriven.configure do |config|
+    # The model that drafts plans and tickets. A stronger model is worth it here.
+    # config.llm_provider = :openai          # or :anthropic, or :cursor (any model on your Cursor
+    # config.llm_model = "gpt-4.1"           # account, e.g. "claude-opus-5-5"; reads your code)
+    # config.request_timeout = 180           # seconds; a large model can need 600 for a full plan
+
+    # Who must approve before the next phase starts.
+    # config.plan_approvals = %w[review qa devops director]
+    # config.ticket_approvals = %w[review]
+
+    # Cursor cloud agents: one agent and one pull request per ticket.
+    # config.agent_model = "composer-2.5"
+    # config.base_branch = "main"
+    # config.max_parallel_agents = 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
+    # config.merge_method = "squash"
+
+    # Guards.
+    # config.estimate_scale = [1, 2, 3, 5, 8]
+    # config.max_estimate = 5
+    # config.max_pr_changed_lines = 800
+    # config.cucumber = true
+
+    # Your team's conventions, added to every agent prompt.
+    # config.team_rules = [
+    #   "Service objects live in app/services and respond to .call.",
+    #   "Authorization goes through Pundit policies, never in controllers."
+    # ]
+  end
+end

data/lib/plan_driven/agent_prompt.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module PlanDriven
+  # What a coding agent is told about one ticket. The plan supplies the context, the ticket the
+  # scope, and the rules are the same ones PrGuard checks afterwards, so the agent is told in
+  # advance exactly what will be verified.
+  class AgentPrompt
+    CONTEXT_SECTIONS = %w[what why architecture database_changes application_changes security testing].freeze
+
+    def initialize(ticket, config: PlanDriven.configuration)
+      @ticket = ticket
+      @plan = ticket.plan
+      @config = config
+    end
+
+    def to_s
+      [intro, ticket_block, plan_block, done_block, rules_block, pr_block].compact.join("\n\n")
+    end
+
+    def pr_title
+      "[#{@ticket.reference}] #{@ticket.title}"
+    end
+
+    private
+
+    def intro
+      "You are implementing one ticket of an approved implementation plan in this Rails application. " \
+        "Implement this ticket only. Other tickets of the plan are handled in their own pull requests."
+    end
+
+    def ticket_block
+      lines = ["# Ticket #{@ticket.reference}: #{@ticket.title}",
+               "Kind: #{@ticket.kind}. Type: #{@ticket.ticket_type}."]
+      lines << "\n#{@ticket.story}" if @ticket.story.present?
+      lines << "\n#{@ticket.description}"
+      lines << "\n## Acceptance criteria"
+      @ticket.criteria.each_with_index { |criterion, index| lines << "#{index + 1}. #{criterion}" }
+      lines << "\n## Implementation notes\n#{@ticket.implementation_notes}" if @ticket.implementation_notes.present?
+      merged = @ticket.dependency_tickets.map { |ticket| "#{ticket.key} #{ticket.title}" }
+      lines << "\nAlready merged into the base branch: #{merged.join("; ")}." if merged.any?
+      lines.join("\n")
+    end
+
+    def plan_block
+      sections = CONTEXT_SECTIONS.filter_map do |key|
+        text = @plan.section(key).strip
+        "## #{@config.template[key]&.title || key}\n#{text}" unless text.empty?
+      end
+      "# Context from plan #{@plan.key}: #{@plan.title}\n\n#{sections.join("\n\n")}"
+    end
+
+    def done_block
+      lines = ["# Definition of done"]
+      lines << "- Specs cover the change (#{@config.spec_paths.join(", ")}), and the existing suite still passes."
+      if @config.cucumber && @ticket.kind != "docs"
+        lines << "- Every acceptance criterion has a Cucumber scenario in " \
+                 "`#{@config.features_path}/#{@plan.slug}/#{@ticket.key.downcase}.feature`. Tag the feature " \
+                 "`#{@ticket.feature_tag}` and each scenario `@ac-N`, where N is the criterion's number above."
+        lines << "- If the app has no Cucumber setup yet, add `cucumber-rails` to the test group and run " \
+                 "`bin/rails generate cucumber:install` in this pull request."
+      end
+      lines << "- Keep the change within #{@config.max_pr_changed_lines} changed lines."
+      lines.join("\n")
+    end
+
+    def rules_block
+      rules = ["Follow the conventions already used in this codebase.",
+               "Schema changes only in migration tickets; this ticket is a #{@ticket.kind} ticket.",
+               "Migrations are additive and reversible. Never remove or rename a column that code still reads.",
+               "Don't edit files under #{@config.docs_path}; they are the approved plan.",
+               *@config.team_rules]
+      "# Rules\n#{rules.map { |rule| "- #{rule}" }.join("\n")}"
+    end
+
+    def pr_block
+      closes = @ticket.issue_number ? "\n- a line `Closes ##{@ticket.issue_number}`" : ""
+      <<~TEXT.strip
+        # Pull request
+        Title it exactly: #{pr_title}
+        In the description include:
+        - `#{@ticket.reference}`#{closes}
+        - each acceptance criterion as a checklist, with the spec or scenario that proves it
+      TEXT
+    end
+  end
+end

data/lib/plan_driven/cli/plan_commands.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module PlanDriven
+  class CLI
+    # Writing, checking and approving the plan.
+    module PlanCommands
+      def cmd_new(*words)
+        title = words.join(" ").strip
+        title = ui.ask("Title of the change:") if title.empty?
+        raise ArgumentError, "A plan needs a title." if title.empty?
+
+        ui.heading "Plan: #{title}"
+        ui.muted "A few questions first. The rest of the plan is drafted from your answers and the schema."
+        answers = interview
+        ui.say
+        ui.say "Drafting with #{LLM.new.label}..."
+        plan, result = delivery.create_plan(title: title, answers: answers)
+        ui.success "#{plan.key} drafted (#{result.attempts} attempt#{"s" unless result.attempts == 1})"
+        result.assumptions.each { |assumption| ui.muted "  assumed: #{assumption}" }
+        ui.report(result.report)
+        show_paths(Renderer.write_plan(plan).values)
+        next_step(plan, result.report)
+      end
+
+      def cmd_list
+        plans = Plan.order(:id)
+        return ui.say("No plans yet. Start one with `plan-driven new \"Title\"`.") if plans.empty?
+
+        ui.table(%w[Plan Title Phase Tickets Revision], plans.map do |plan|
+          [plan.key, plan.title.truncate(50), plan.status.tr("_", " "), plan.tickets.size, plan.revision]
+        end)
+      end
+
+      def cmd_show(reference = nil)
+        plan = find_plan(reference)
+        if @options[:section]
+          ui.say plan.section(@options[:section])
+        else
+          ui.say Renderer::Markdown.plan(plan)
+        end
+      end
+
+      def cmd_edit(reference = nil, key = nil)
+        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}")
+        return ui.muted("No change.") if text.strip == plan.section(section.key).strip
+
+        delivery.edit_section(plan, section.key, text)
+        ui.success "#{section.title} updated; #{plan.key} is now revision #{plan.revision} (#{plan.status})"
+        ui.report(Guards::Report.from_h(plan.guard_report))
+      end
+
+      def cmd_redraft(reference = nil, key = nil, *instruction)
+        plan = find_plan(reference)
+        if instruction.empty?
+          raise ArgumentError,
+                "Say what to change, for example: redraft PD-1 testing \"add permission cases\""
+        end
+
+        ui.say "Redrafting #{key}..."
+        ui.say delivery.redraft_section(plan, key, instruction.join(" "))
+        ui.report(Guards::Report.from_h(plan.reload.guard_report))
+      end
+
+      def cmd_check(reference = nil)
+        plan = find_plan(reference)
+        report = delivery.check_plan(plan)
+        ui.report(report)
+        next_step(plan, report)
+      end
+
+      def cmd_submit(reference = nil)
+        plan = find_plan(reference)
+        delivery.submit(plan)
+        ui.success "#{plan.key} revision #{plan.revision} is in review"
+        ui.say "Approvals needed: #{plan.missing_approvals.join(", ")}. `plan-driven approve #{plan.key} --as ROLE`"
+      end
+
+      def cmd_approve(reference = nil)
+        plan = find_plan(reference)
+        role = @options[:role] || PlanDriven.configuration.plan_approvals.first
+        missing = delivery.approve_plan(plan, role: role, note: @options[:note])
+        ui.success "#{plan.key} approved as #{role} by #{delivery.actor}"
+        if missing.empty?
+          ui.success "Every approval is in. #{plan.key} is approved; " \
+                     "`plan-driven tickets #{plan.key}` drafts the tickets."
+        else
+          ui.say "Still needed: #{missing.join(", ")}"
+        end
+      end
+
+      def cmd_reject(reference = nil)
+        plan = find_plan(reference)
+        raise ArgumentError, "Say what needs to change with --note." if @options[:note].to_s.empty?
+
+        role = @options[:role] || PlanDriven.configuration.plan_approvals.first
+        delivery.reject_plan(plan, role: role, note: @options[:note])
+        ui.warn "#{plan.key} sent back to draft: #{@options[:note]}"
+      end
+
+      def cmd_pdf(reference = nil)
+        plan = find_plan(reference)
+        paths = Renderer.write_plan(plan)
+        ui.success "#{plan.key} written"
+        show_paths(paths.values)
+        return if paths[:pdf]
+
+        ui.warn "No Chrome or Chromium found, so no PDF; set config.pdf_renderer to use another tool."
+      end
+
+      def cmd_log(reference = nil)
+        plan = find_plan(reference)
+        ui.table(%w[When Event Ticket By Details], plan.events.map do |event|
+          [event.created_at.strftime("%Y-%m-%d %H:%M"), event.name, event.ticket&.key.to_s, event.actor,
+           event.payload.to_h.map { |k, v| "#{k}=#{Array(v).join(",")}" }.join(" ").truncate(60)]
+        end)
+      end
+
+      private
+
+      def interview
+        PlanDriven.configuration.template.asked.to_h do |section|
+          answer = ""
+          loop do
+            answer = ui.ask_multiline("#{section.title}: #{section.question}")
+            break unless section.required && answer.strip.empty?
+
+            ui.warn "#{section.title} is required."
+          end
+          [section.key, answer]
+        end
+      end
+
+      def next_step(plan, report)
+        if report.ok?
+          ui.say "Next: read #{plan.key} (`plan-driven show #{plan.key}` or the PDF), " \
+                 "then `plan-driven submit #{plan.key}`."
+        else
+          ui.say "Fix the errors with `plan-driven edit #{plan.key} SECTION` or `plan-driven redraft #{plan.key} " \
+                 "SECTION \"instruction\"`, then `plan-driven check #{plan.key}`."
+        end
+      end
+
+      def edit_in_editor(text, name)
+        editor = ENV["VISUAL"].presence || ENV["EDITOR"].presence or
+          raise ConfigurationError, "Set $EDITOR (for example `export EDITOR=\"code --wait\"`) to edit sections."
+        Tempfile.create([name, ".md"]) do |file|
+          file.write(text)
+          file.flush
+          system("#{editor} #{file.path}") or raise Error, "The editor exited with an error; nothing changed."
+          File.read(file.path)
+        end
+      end
+    end
+  end
+end

data/lib/plan_driven/cli/setup_commands.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module PlanDriven
+  class CLI
+    # Keys and a health check. These work outside a Rails application too.
+    module SetupCommands
+      PROMPTS = {
+        "openai_api_key" => "OpenAI API key (drafting plans and tickets)",
+        "anthropic_api_key" => "Anthropic API key (optional, if you draft with Claude)",
+        "cursor_api_key" => "Cursor API key (cloud agents, and drafting with llm_provider :cursor)",
+        "github_token" => "GitHub token with repo scope (issues, pull requests, merge)"
+      }.freeze
+
+      def cmd_configure
+        ui.heading "plan-driven keys"
+        ui.muted "Stored in #{Credentials.path} (0600). Keys already in the environment are used as they are."
+        PROMPTS.each do |name, label|
+          source = Credentials.source(name)
+          if source
+            ui.muted "  #{label}: set (#{source})"
+            next unless ui.confirm?("  Replace it in #{Credentials.path}?")
+          end
+          value = ui.secret("  #{label}, Enter to skip:")
+          next if value.empty?
+
+          Credentials.store(name, value)
+          ui.success "  stored"
+        end
+      end
+
+      def cmd_doctor
+        ui.heading "plan-driven #{PlanDriven::VERSION}"
+        check_application
+        ui.muted "LLM: #{LLM.new.label}"
+        check_cursor_llm
+        Credentials::KEYS.each_key do |name|
+          next if unused_llm_key?(name)
+
+          source = Credentials.source(name)
+          source ? ui.success("#{name}: #{source}") : ui.warn("#{name}: not set")
+        end
+        repository = Repository.slug
+        repository ? ui.success("GitHub repository: #{repository}") : ui.warn("GitHub repository: none found")
+        browser = Renderer::PDF.browser
+        browser ? ui.success("PDF: #{File.basename(browser)}") : ui.warn("PDF: no Chrome or Chromium, HTML only")
+        check_cursor
+      end
+
+      private
+
+      # Outside an app the keys can still be checked; inside one, the initializer decides the
+      # provider and repository, so boot it first.
+      def check_application
+        return ui.muted("Not in a Rails application; showing defaults.") unless File.exist?("config/environment.rb")
+
+        boot_application
+        ui.success "Rails application: plan_driven tables present"
+      rescue Error => e
+        ui.error e.message
+      end
+
+      def check_agent_model(agents)
+        model = PlanDriven.configuration.agent_model
+        return ui.warn("Agent model: Cursor's default. Set config.agent_model if agents fail to start.") unless model
+
+        if agents.model_ids.include?(model)
+          ui.success "Agent model: #{model}"
+        else
+          ui.error "Agent model: #{model} isn't available to this key; `GET /v1/models` lists the ones that are"
+        end
+      end
+
+      def unused_llm_key?(name)
+        %w[openai_api_key anthropic_api_key].include?(name) && name != PlanDriven.configuration.llm_key_name.to_s
+      end
+
+      def check_cursor_llm
+        config = PlanDriven.configuration
+        return unless config.llm_provider.to_sym == :cursor
+
+        ok, detail = CursorLLM.new(config).check
+        ok ? ui.success("Cursor SDK: #{detail}") : ui.error("Cursor SDK: #{detail}")
+      end
+
+      def check_cursor
+        return unless Credentials.fetch(:cursor_api_key)
+
+        agents = CursorAgents.new
+        info = agents.me
+        ui.success "Cursor API: #{info["userEmail"] || info["apiKeyName"] || "connected"}"
+        check_agent_model(agents)
+      rescue Error => e
+        ui.error "Cursor API: #{e.message}"
+      end
+    end
+  end
+end

data/lib/plan_driven/cli/ticket_commands.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module PlanDriven
+  class CLI
+    # Tickets, agents, pull requests, evidence and the report.
+    module TicketCommands
+      def cmd_tickets(reference = nil, *instruction)
+        plan = find_plan(reference)
+        ui.say "Drafting tickets for #{plan.key} with #{LLM.new.label}..."
+        result = delivery.draft_tickets(plan, instruction: instruction.join(" ").presence)
+        ui.report(result.report, ok_message: "Tickets pass every check")
+        show_tickets(plan.tickets)
+        ui.say "Next: review them in docs/plans/#{plan.slug}/plan.pdf, then `plan-driven approve-tickets #{plan.key}`."
+      end
+
+      def cmd_approve_tickets(reference = nil)
+        plan = find_plan(reference)
+        role = @options[:role] || PlanDriven.configuration.ticket_approvals.first
+        missing = delivery.approve_tickets(plan, role: role, note: @options[:note])
+        return ui.say("Approved as #{role}. Still needed: #{missing.join(", ")}") if missing.any?
+
+        ui.success "#{plan.tickets.size} tickets approved"
+        plan.tickets.select(&:issue_number).each do |ticket|
+          ui.muted "  #{ticket.key} -> issue ##{ticket.issue_number}"
+        end
+        ui.say "Next: `plan-driven develop #{plan.key}` hands the ready tickets to Cursor agents."
+      end
+
+      def cmd_prompt(reference = nil)
+        ui.say AgentPrompt.new(find_ticket(reference)).to_s
+      end
+
+      def cmd_develop(reference = nil, *only)
+        plan = find_plan(reference)
+        starting = delivery.startable(plan, only: only)
+        return explain_waiting(plan) if starting.empty?
+
+        starting.each { |ticket| ui.say "  #{ticket.key} #{ticket.title}" }
+        return ui.muted("Nothing started.") unless ui.confirm?("Start #{starting.size} Cursor cloud agent(s)?")
+
+        delivery.develop(plan, only: starting.map(&:key)).each do |ticket|
+          ui.success "#{ticket.key} agent started: #{ticket.agent_url}"
+        end
+        ui.say "Each agent opens a pull request when it finishes. `plan-driven status #{plan.key}` checks on them."
+      end
+
+      def cmd_status(reference = nil)
+        plan = find_plan(reference)
+        delivery.refresh(plan)
+        ui.heading "#{plan.key} #{plan.title}: #{plan.status.tr("_", " ")}"
+        show_tickets(plan.tickets)
+        ui.muted(plan.status == "in_development" ? development_hint(plan) : Workflow::PLAN_DESCRIPTIONS[plan.status])
+      end
+
+      def development_hint(plan)
+        tickets = plan.tickets.to_a
+        waiting = tickets.find { |t| t.status == "pr_open" }
+        return "Next: `plan-driven review #{waiting.reference}`" if waiting
+
+        approved = tickets.find { |t| t.status == "pr_approved" }
+        return "Next: `plan-driven merge #{approved.reference}`" if approved
+        return "Next: `plan-driven develop #{plan.key}`" if delivery.startable(plan).any?
+
+        Workflow::PLAN_DESCRIPTIONS[plan.status]
+      end
+
+      def cmd_review(reference = nil)
+        ticket = find_ticket(reference)
+        ui.say "Reviewing #{ticket.pr_url}"
+        report = delivery.review(ticket)
+        report.passes.each { |message| ui.say "  ✓ #{message}" }
+        ui.report(report, ok_message: "The pull request passes every check")
+      end
+
+      def cmd_approve_pr(reference = nil)
+        ticket = find_ticket(reference)
+        report = delivery.approve_pr(ticket, note: @options[:note])
+        ui.report(report)
+        ui.success "#{ticket.reference} pull request approved by #{delivery.actor}"
+        ui.say "Next: `plan-driven merge #{ticket.reference}`"
+      end
+
+      def cmd_feedback(reference = nil, *words)
+        ticket = find_ticket(reference)
+        feedback = words.join(" ").presence || ui.ask_multiline("Feedback for the agent:")
+        raise ArgumentError, "No feedback given." if feedback.strip.empty?
+
+        delivery.request_changes(ticket, feedback)
+        ui.success "Sent to #{ticket.reference}'s agent; it will push to the same pull request"
+      end
+
+      def cmd_merge(reference = nil)
+        ticket = find_ticket(reference)
+        ui.say "#{ticket.reference} #{ticket.title}"
+        ui.say "#{ticket.pr_url}, approved by #{ticket.pr_approved_by}"
+        return ui.muted("Not merged.") unless ui.confirm_word?(
+          "This merges into #{PlanDriven.configuration.base_branch}.", ticket.key
+        )
+
+        delivery.merge(ticket)
+        ui.success "#{ticket.reference} merged (#{ticket.merged_sha.to_s[0, 7]})"
+        waiting = ticket.plan.tickets.select(&:ready?)
+        ui.say "Now ready: #{waiting.map(&:key).join(", ")}. `plan-driven develop #{ticket.plan.key}`" if waiting.any?
+        return unless ticket.plan.status == "delivered"
+
+        ui.success "Every ticket is merged. `plan-driven report #{ticket.plan.key}`"
+      end
+
+      def cmd_evidence(reference = nil)
+        plan = find_plan(reference)
+        run = if @options[:from]
+                Evidence.record(plan, File.read(@options[:from]), command: "imported #{@options[:from]}",
+                                                                  actor: delivery.actor)
+              else
+                ui.say "Running cucumber --tags \"#{Evidence.tag_expression(plan)}\""
+                delivery.evidence(plan)
+              end
+        rows = Evidence.matrix(plan)
+        ui.table(%w[AC Result Criterion], rows.map do |row|
+          ["#{row.ticket.key}.#{row.number}", row.status, row.criterion.truncate(70)]
+        end)
+        ui.say
+        run.passed? ? ui.success(Evidence.summary_line(plan)) : ui.warn("#{run.status}: #{Evidence.summary_line(plan)}")
+      end
+
+      def cmd_report(reference = nil)
+        plan = find_plan(reference)
+        paths = delivery.report(plan)
+        ui.success "Delivery report for #{plan.key} written"
+        show_paths(paths.values)
+      end
+
+      private
+
+      def explain_waiting(plan)
+        running = plan.tickets.count(&:active_agent?)
+        if plan.tickets.any?(&:ready?) && running >= PlanDriven.configuration.max_parallel_agents
+          return ui.say("#{running} agents are already running (the limit).")
+        end
+
+        plan.tickets.select { |ticket| ticket.status == "approved" }.each do |ticket|
+          ui.muted "  #{ticket.key} waits for #{ticket.blocked_by.join(", ")} to merge"
+        end
+        ui.say("No ticket is ready to start.")
+      end
+
+      def show_tickets(tickets)
+        ui.table(%w[# Title Kind Pts Status PR], tickets.map do |ticket|
+          [ticket.key, ticket.title.truncate(48), ticket.kind, ticket.estimate, ticket.status.tr("_", " "),
+           ticket.pr_url.to_s]
+        end)
+      end
+    end
+  end
+end