ace-coworker 0.6.0

data/lib/ace/coworker/atoms/role_preset_schema.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Ace
+  module Coworker
+    module Atoms
+      # Pure validation of a raw role preset hash (the shipped
+      # .ace-defaults/coworker/roles/*.yml files and their project
+      # overrides). Field-specific errors, no IO, no defaults.
+      class RolePresetSchema
+        REQUIRED_FIELDS = %w[name instructions start_prompt].freeze
+
+        # @param raw [Hash, nil] parsed preset hash
+        # @return [Array<String>] field-specific error messages (empty when valid)
+        def self.errors(raw)
+          return ["preset is empty"] if raw.nil? || (!raw.is_a?(Hash) && raw.to_s.strip.empty?)
+          return ["preset must be a mapping, got #{raw.class}"] unless raw.is_a?(Hash)
+
+          errors = []
+          REQUIRED_FIELDS.each do |field|
+            value = raw[field]
+            if value.nil? || value.to_s.strip.empty?
+              errors << "missing required field '#{field}'"
+            end
+          end
+          errors.concat(non_empty_string_error(raw, "description")) if raw.key?("description")
+          errors.concat(nested_mapping_errors(raw, "reporting"))
+          errors.concat(nested_mapping_errors(raw, "errors"))
+          errors.concat(reporting_errors(raw))
+          errors.concat(error_rules_errors(raw))
+          errors
+        end
+
+        # Preset → config-shaped hash with the role's own fields only
+        # (identity fields are supplied by the commission, not the preset).
+        def self.normalize(raw)
+          {
+            "name" => str(raw["name"]),
+            "description" => str(raw["description"]),
+            "instructions" => str(raw["instructions"]),
+            "start_prompt" => raw["start_prompt"].to_s.strip,
+            "reporting" => nested_str(raw, "reporting", "channel"),
+            "errors" => nested_str(raw, "errors", "on_failure")
+          }
+        end
+
+        class << self
+          private
+
+          def non_empty_string_error(raw, field)
+            value = raw[field]
+            value.is_a?(String) && !value.strip.empty? ? [] : ["'#{field}' must be a non-empty string"]
+          end
+
+          def reporting_errors(raw)
+            channel = nested_str(raw, "reporting", "channel")
+            return [] if channel.empty?
+
+            ConfigSchema::CHANNELS.include?(channel) ? [] :
+              ["reporting.channel '#{channel}' is not one of: #{ConfigSchema::CHANNELS.join(', ')}"]
+          end
+
+          def error_rules_errors(raw)
+            on_failure = nested_str(raw, "errors", "on_failure")
+            return [] if on_failure.empty?
+
+            ConfigSchema::ON_FAILURE.include?(on_failure) ? [] :
+              ["errors.on_failure '#{on_failure}' is not one of: #{ConfigSchema::ON_FAILURE.join(', ')}"]
+          end
+
+          def nested_mapping_errors(raw, section)
+            value = raw[section]
+            return [] if value.nil? || value.is_a?(Hash)
+
+            ["'#{section}' must be a mapping, got #{value.class}"]
+          end
+
+          def nested_str(raw, section, key)
+            value = raw[section]
+            return "" unless value.is_a?(Hash)
+
+            str(value[key])
+          end
+
+          def str(value)
+            value.to_s.strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/atoms/round_record_schema.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ace
+  module Coworker
+    module Atoms
+      # Pure validation of a single review-round record at the store
+      # boundary (Atoms::RolePresetSchema.errors pattern): field-specific
+      # errors, no IO, no coercion. A record must be a Hash with string
+      # keys; "type" full|delta, "status" completed|aborted, "confirmed"
+      # an array of hashes with string id+severity, "resolved" an array
+      # of strings. Garbage must surface as an actionable Ace::Coworker
+      # Error, never a TypeError or a silently wrong verdict.
+      module RoundRecordSchema
+        TYPES = %w[full delta].freeze
+        STATUSES = %w[completed aborted].freeze
+
+        # @param record [Object] candidate round record
+        # @return [Array<String>] field-specific error messages (empty when valid)
+        def self.errors(record)
+          return ["round record must be a Hash with string keys, got #{record.class}"] unless record.is_a?(Hash)
+          return ["round record keys must be strings, got: #{record.keys.inspect}"] if record.keys.any? { |k| !k.is_a?(String) }
+
+          errors = []
+          errors << "'type' must be one of: #{TYPES.join(', ')}" unless TYPES.include?(record["type"])
+          errors << "'status' must be one of: #{STATUSES.join(', ')}" unless STATUSES.include?(record["status"])
+          errors.concat(confirmed_errors(record["confirmed"]))
+          errors.concat(resolved_errors(record["resolved"]))
+          errors
+        end
+
+        class << self
+          private
+
+          def confirmed_errors(value)
+            return ["'confirmed' must be an array, got #{value.class}"] unless value.is_a?(Array)
+
+            value.each_with_index.flat_map do |finding, index|
+              if !finding.is_a?(Hash)
+                ["'confirmed[#{index}]' must be a Hash, got #{finding.class}"]
+              elsif finding.keys.any? { |k| !k.is_a?(String) }
+                ["'confirmed[#{index}]' keys must be strings"]
+              elsif !finding["id"].is_a?(String) || finding["id"].empty? ||
+                    !finding["severity"].is_a?(String) || finding["severity"].empty?
+                ["'confirmed[#{index}]' must have non-empty string 'id' and 'severity'"]
+              else
+                []
+              end
+            end
+          end
+
+          def resolved_errors(value)
+            return ["'resolved' must be an array, got #{value.class}"] unless value.is_a?(Array)
+
+            value.each_with_index.map do |id, index|
+              id.is_a?(String) && !id.empty? ? nil : "'resolved[#{index}]' must be a non-empty string"
+            end.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/atoms/round_rule.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Ace
+  module Coworker
+    module Atoms
+      # Pure 3/2/10 review-convergence rule (8xg.t.sbz.4.2 / contract):
+      # minimum 3 full rounds, the last 2 consecutive completed full rounds
+      # without confirmed High/Critical, and no earlier unresolved
+      # High/Critical; maximum 10 full rounds - satisfying the rule at
+      # round 10 succeeds, otherwise the verdict is :escalate (an explicit
+      # outcome for the reviewer role to route via ace-hitl, never an
+      # exception). Delta/fix-diff rounds never advance the counters; the
+      # caller records a delta round that still reviews every changed part
+      # as type "full" (reviewer.wf.md rule 6). Interrupted/aborted rounds
+      # are not clean. No IO, no writes.
+      module RoundRule
+        MIN_FULL_ROUNDS = 3
+        MAX_FULL_ROUNDS = 10
+        REQUIRED_CLEAN_STREAK = 2
+        HIGH_SEVERITIES = %w[high critical].freeze
+
+        # @param records [Array<Hash>] ordered round records, each with:
+        #   "type" => "full" | "delta",
+        #   "status" => "completed" | "aborted",
+        #   "confirmed" => Array<{"id" => String, "severity" => String}>,
+        #   "resolved" => Array<String> finding ids resolved by this round
+        # @return [Hash] {verdict: :continue | :accept | :escalate,
+        #   full_rounds:, completed_full_rounds:, consecutive_clean:,
+        #   unresolved_high_critical: [ids]}
+        def self.evaluate(records)
+          records = Array(records)
+          resolved_ids = records.flat_map { |r| list(r["resolved"]) }.to_set
+          unresolved = confirmed_high(records).reject { |id| resolved_ids.include?(id) }.uniq
+
+          full_rounds = records.count { |r| full?(r) }
+          completed_full = records.count { |r| full?(r) && completed?(r) }
+          streak = clean_streak(records)
+
+          # The 10-round cap is terminal: acceptance is possible only at
+          # or before round 10, so a satisfying state that materializes
+          # at round 11+ escalates instead of flipping back to :accept.
+          acceptable = completed_full >= MIN_FULL_ROUNDS &&
+                       streak >= REQUIRED_CLEAN_STREAK && unresolved.empty? &&
+                       full_rounds <= MAX_FULL_ROUNDS
+          verdict = if acceptable
+                      :accept
+                    elsif full_rounds >= MAX_FULL_ROUNDS
+                      :escalate
+                    else
+                      :continue
+                    end
+
+          {verdict: verdict, full_rounds: full_rounds,
+           completed_full_rounds: completed_full, consecutive_clean: streak,
+           unresolved_high_critical: unresolved}
+        end
+
+        # A record is a clean round only when it is a completed full round
+        # with no confirmed High/Critical finding; aborted full rounds and
+        # full rounds with High/Critical reset the streak. Delta rounds
+        # never advance the streak, but a delta that CONFIRMS a
+        # High/Critical finding breaks it — even when the same delta (or a
+        # later fix delta) resolves the finding: code that just produced a
+        # High defect needs renewed clean full-round evidence, never the
+        # stale streak from before the finding. Deltas without a confirmed
+        # High/Critical (e.g. a pure fix delta) stay transparent.
+        def self.clean_streak(records)
+          streak = 0
+          records.reverse_each do |record|
+            unless full?(record)
+              break if confirmed_high([record]).any?
+
+              next
+            end
+
+            break unless completed?(record) && confirmed_high([record]).empty?
+
+            streak += 1
+          end
+          streak
+        end
+
+        def self.confirmed_high(records)
+          records.flat_map { |r| list(r["confirmed"]) }
+                 .select { |f| HIGH_SEVERITIES.include?(f["severity"].to_s.downcase) }
+                 .map { |f| f["id"].to_s }
+        end
+
+        def self.full?(record)
+          record["type"].to_s == "full"
+        end
+
+        def self.completed?(record)
+          record["status"].to_s == "completed"
+        end
+
+        def self.list(value)
+          Array(value)
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/cli/commands/commission.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Coworker
+    module CLI
+      module Commands
+        class Commission < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Instantiate a role preset into the coworker run config"
+
+          option :role, desc: "Role preset name (required)"
+          option :task, desc: "Task reference that must resolve in this worktree (required)"
+          option :assignment, desc: "Assignment id pinned to the role (required)"
+          option :overseer, desc: "Overseer reporting address (required)"
+          option :"start-prompt", desc: "Literal start prompt overriding the preset template"
+          option :config, desc: "Config path (default from cascade: .ace-local/coworker/config.yml)"
+          option :force, type: :boolean, default: false, desc: "Allow overwriting an existing config"
+          option :"dry-run", type: :boolean, default: false,
+            desc: "Render the resolved config without writing"
+          option :format, default: "table", desc: "Output format (table, json)"
+          option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
+          option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
+
+          def initialize(orchestrator: nil)
+            super()
+            @orchestrator = orchestrator
+          end
+
+          def call(role: nil, task: nil, assignment: nil, overseer: nil, **options)
+            role = role.to_s.strip
+            task = task.to_s.strip
+            assignment = assignment.to_s.strip
+            overseer = overseer.to_s.strip
+            required = [["--role", role], ["--task", task],
+              ["--assignment", assignment], ["--overseer", overseer]].each_with_object([]) do |(flag, value), missing|
+              missing << flag if value.empty?
+            end
+            unless required.empty?
+              raise Ace::Support::Cli::Error,
+                "#{required.join(', ')} #{required.size == 1 ? 'is' : 'are'} required. " \
+                "Usage: ace-coworker commission --role worker --task <ref> --assignment <id> --overseer <addr>"
+            end
+
+            orchestrator = @orchestrator || build_orchestrator(options[:config])
+            result = orchestrator.call(
+              role: role, task: task, assignment: assignment, overseer: overseer,
+              start_prompt: options[:"start-prompt"],
+              force: options[:force] == true, dry_run: options[:"dry-run"] == true
+            )
+
+            return if options[:quiet]
+
+            render(result, options[:format])
+          rescue Ace::Coworker::Error => e
+            raise Ace::Support::Cli::Error, e.message
+          end
+
+          private
+
+          def build_orchestrator(config_path)
+            project_root = Molecules::ProjectRoot.new.resolve
+            Organisms::CommissionOrchestrator.new(
+              project_root: project_root,
+              preset_loader: Molecules::RolePresetLoader.new(project_root: project_root),
+              task_probe: Molecules::TaskProbe.new(project_root: project_root),
+              assignment_metadata: Molecules::AssignmentMetadata.new(project_root: project_root),
+              config_path: config_path
+            )
+          end
+
+          def render(result, format)
+            if format == "json"
+              puts JSON.pretty_generate(result.to_h)
+            else
+              puts render_table(result)
+            end
+          end
+
+          def render_table(result)
+            lines = ["Coworker commission"]
+            lines << "  role:          #{result.role} (preset source: #{result.preset_source})"
+            lines << "  task:          #{result.task}"
+            lines << "  assignment:    #{result.assignment}"
+            lines << "  overseer:      #{result.overseer}"
+            lines << "  config_path:   #{result.config_path}"
+            lines << format("  result:        %s", result.dry_run ? "resolved (dry-run, nothing written)" : "written")
+            result.config.each do |key, value|
+              rendered = value.is_a?(Hash) ? value.map { |k, v| "#{k}=#{v}" }.join(" ") : value
+              lines << "    #{key}: #{rendered}"
+            end
+            lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/cli/commands/gate.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Coworker
+    module CLI
+      module Commands
+        class Gate < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Evaluate the pre-merge integration gate and print :ready or :blocked with reasons"
+
+          example [
+            "gate --candidate-head 1a2b3c4 --review-head 1a2b3c4 --review-verdict accept \\",
+            "     --tests executed,passed --dep 8xg.t.sbz.4.2=integrated",
+            "gate --candidate-head 1a2b3c4 --review-head 0d0e0f --review-verdict accept \\",
+            "     --tests executed,passed --dep 8xg.t.sbz.4.2=missing"
+          ]
+
+          option :candidate_head, desc: "Current head of the candidate branch (omit when unknown)"
+          option :review_head, desc: "Candidate head the review verdict covers"
+          option :review_verdict, required: true, desc: "Independent review verdict (accept, continue, escalate)"
+          option :tests, type: :array, default: [], desc: "Test evidence flags: executed, passed"
+          option :dep, type: :array, default: [], desc: "Dependency states as name=integrated|missing pairs"
+          option :format, default: "table", desc: "Output format (table, json)"
+          option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
+          option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
+
+          def call(candidate_head: nil, review_head: nil, review_verdict: nil, tests: [], dep: [],
+                   format: "table", **options)
+            result = Atoms::IntegrationGate.evaluate(
+              "candidate_head" => candidate_head.to_s,
+              "review" => {"head" => review_head.to_s, "verdict" => review_verdict.to_s},
+              "tests" => tests_flags(tests),
+              "dependencies" => dependency_states(dep)
+            )
+
+            return if options[:quiet]
+
+            if format == "json"
+              puts JSON.pretty_generate(json_payload(result))
+            else
+              puts render(result)
+            end
+          end
+
+          private
+
+          def tests_flags(tests)
+            flags = Array(tests).flat_map { |value| value.to_s.split(",") }.map { |f| f.strip.downcase }.reject(&:empty?)
+            flags.each do |flag|
+              unless %w[executed passed].include?(flag)
+                raise Ace::Support::Cli::Error, "invalid --tests '#{flag}' (expected: executed, passed)"
+              end
+            end
+            {"executed" => flags.include?("executed"), "passed" => flags.include?("passed")}
+          end
+
+          def dependency_states(dep)
+            Array(dep).each_with_object({}) do |pair, states|
+              name, state = pair.to_s.split("=", 2)
+              name = name.to_s.strip
+              if name.empty? || state.nil?
+                raise Ace::Support::Cli::Error, "invalid --dep '#{pair}' (expected name=integrated|missing)"
+              end
+              raise Ace::Support::Cli::Error, "duplicate --dep '#{name}'" if states.key?(name)
+
+              states[name] = state.strip.downcase == "integrated"
+            end
+          end
+
+          def json_payload(result)
+            {
+              "verdict" => result[:verdict].to_s,
+              "reasons" => result[:reasons],
+              "failed_checks" => result[:failed_checks].map(&:to_s)
+            }
+          end
+
+          def render(result)
+            lines = ["Coworker integration gate"]
+            lines << "  verdict:        #{result[:verdict]}"
+            result[:reasons].each { |reason| lines << "  blocked:        #{reason}" }
+            lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/cli/commands/prepare.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Coworker
+    module CLI
+      module Commands
+        class Prepare < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Accept a preparation commission and ensure the task worktree"
+
+          option :task, desc: "Task reference (required)"
+          option :roles, type: :array,
+            desc: "Expected role sequence, repeatable and comma-separated (e.g., --roles worker,reviewer)"
+          option :to, desc: "Escalation recipient (default: coworker config overseer)"
+          option :config, desc: "Path to coworker config for the overseer fallback"
+          option :"dry-run", type: :boolean, default: false,
+            desc: "Resolve and detect conflicts without any writes"
+          option :format, default: "table", desc: "Output format (table, json)"
+          option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
+          option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
+
+          def initialize(orchestrator: nil)
+            super()
+            @orchestrator = orchestrator
+          end
+
+          def call(task: nil, roles: nil, **options)
+            task_ref = task.to_s.strip
+            raise Ace::Support::Cli::Error, "--task is required. Usage: ace-coworker prepare --task <ref>" if task_ref.empty?
+
+            role_list = normalize_roles(roles)
+            if role_list.empty?
+              raise Ace::Support::Cli::Error,
+                "--roles is required. Usage: ace-coworker prepare --task <ref> --roles worker,reviewer"
+            end
+
+            orchestrator = @orchestrator || Organisms::PrepareOrchestrator.new
+            result = orchestrator.call(task_ref: task_ref, roles: role_list,
+              to: options[:to], config_path: options[:config],
+              dry_run: options[:"dry-run"] == true)
+
+            # Exit semantics first: quiet suppresses output, never the
+            # non-zero exit a conflict must keep.
+            if result.conflict?
+              render(result, options[:format]) unless options[:quiet]
+              conflict = result.conflict
+              raise Ace::Support::Cli::Error,
+                "preparation conflict: #{conflict['kind']} - #{first_line(conflict['detail'])}"
+            end
+
+            return if options[:quiet]
+
+            render(result, options[:format])
+          rescue Ace::Coworker::Error => e
+            raise Ace::Support::Cli::Error, e.message
+          end
+
+          private
+
+          def normalize_roles(raw_roles)
+            Array(raw_roles)
+              .flat_map { |entry| entry.to_s.split(",") }
+              .map(&:strip)
+              .reject(&:empty?)
+              .uniq
+          end
+
+          def first_line(text)
+            text.to_s.lines.first.to_s.strip
+          end
+
+          def report_line(report)
+            return "not sent (#{report['error']})" if report["error"]
+
+            delivery = report["delivered"] ? "delivered" : "not delivered (retry: ace-hitl send #{report['event']})"
+            "readiness event #{report['event']} (#{delivery})"
+          end
+
+          def render(result, format)
+            if format == "json"
+              puts JSON.pretty_generate(result.to_h)
+            else
+              puts render_table(result)
+            end
+          end
+
+          def render_table(result)
+            lines = ["Coworker prepare"]
+            lines << "  task:       #{result.task}"
+            lines << "  task_path:  #{result.task_path}"
+            lines << "  roles:      #{result.roles.join(', ')}"
+            if result.conflict?
+              conflict = result.conflict
+              lines << "  conflict:   #{conflict['kind']}"
+              conflict["detail"].to_s.lines.map(&:strip).reject(&:empty?).each do |line|
+                lines << "    #{line}"
+              end
+              if conflict["hitl_event"]
+                delivery = conflict["delivered"] ? "delivered" : "not delivered (retry: ace-hitl send #{conflict['hitl_event']})"
+                lines << "  event:      #{conflict['hitl_event']} (#{delivery})"
+              end
+            else
+              worktree = result.worktree
+              lines << "  worktree:   #{worktree['path']}"
+              lines << "  branch:     #{worktree['branch']}"
+              lines << format("  result:     %s", worktree["disposition"])
+            end
+            unless result.assignments.empty?
+              lines << "  sequence:"
+              result.assignments.each do |entry|
+                lines << "    #{entry['position']}/#{entry['of']} #{entry['role']}: " \
+                  "#{entry['assignment']} (#{entry['disposition']}, #{entry['steps']} steps)"
+                lines << "        expected outcome: #{entry['outcome']}"
+              end
+            end
+            unless result.start_configs.empty?
+              lines << "  start configs:"
+              result.start_configs.each do |entry|
+                lines << "    #{entry['role']}: #{entry['path']} (#{entry['disposition']}, " \
+                  "assignment #{entry['assignment']})"
+              end
+            end
+            if result.report
+              lines << "  report:     #{report_line(result.report)}"
+            end
+            result.worktree_assignments.each do |assignment|
+              lines << "  assignment: #{assignment['id']} #{assignment['state']} (#{assignment['progress']})"
+            end
+            lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/cli/commands/report.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Coworker
+    module CLI
+      module Commands
+        class Report < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Record the assignment outcome and report it through ace-hitl"
+
+          option :config, desc: "Path to coworker config (default: .ace-local/coworker/config.yml)"
+          option :assignment, desc: "Assignment ID (default: config assignment)"
+          option :result, desc: "Force result (success, error); default: derived from the ace-assign verdict"
+          option :message, desc: "Explicit failure cause (required for error without step evidence)"
+          option :step, desc: "Step ref to report (default: failed step / last step)"
+          option :"no-send", type: :boolean, desc: "Create the HITL event without delivering it"
+          option :"dry-run", type: :boolean, desc: "Show the derived outcome; nothing is written or sent"
+          option :format, default: "table", desc: "Output format (table, json)"
+          option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
+          option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
+
+          def call(**options)
+            orchestrator = Organisms::ReportOrchestrator.new
+            result = orchestrator.call(
+              config_path: options[:config],
+              assignment: options[:assignment],
+              result: options[:result],
+              message: options[:message],
+              step: options[:step],
+              no_send: options[:"no-send"] == true,
+              dry_run: options[:"dry-run"] == true
+            )
+
+            # Exit semantics first: quiet suppresses output, never the
+            # non-zero exit an error outcome or delivery failure must keep.
+            if result.exit_code != 0
+              raise Ace::Support::Cli::Error, result.message
+            end
+
+            return if options[:quiet]
+
+            if options[:format] == "json"
+              puts JSON.pretty_generate(to_h(result))
+            else
+              puts render(result)
+            end
+          rescue Ace::Coworker::Error => e
+            raise Ace::Support::Cli::Error, e.message
+          end
+
+          private
+
+          def to_h(result)
+            {
+              "result" => result.outcome.result,
+              "record" => result.record_path,
+              "event_id" => result.event_id,
+              "delivery" => result.delivery,
+              "message" => result.message
+            }
+          end
+
+          def render(result)
+            lines = ["Coworker report"]
+            lines << "  outcome:    #{result.outcome.result}"
+            lines << "  record:     #{result.record_path}" if result.record_path
+            lines << "  event:      #{result.event_id}" if result.event_id
+            lines << "  delivery:   #{result.delivery}" if result.delivery
+            lines << "  #{result.message}" if result.message
+            lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end