hecks 5.0.0 → 7.0.0

data/lib/hecks/tickets/bluebook/tickets.bluebook

@@ -1,4 +1,4 @@
-# The Tickets chapter: what a maintainer observed about Hecks that needs a decision or a fix, the
+# The Tickets bluebook: what a maintainer observed about Hecks that needs a decision or a fix, the
 # and the decisions that settle them.
 #
 # QualityControl has its own Ticket, the issue raised for a Bug in an outside tracker, and the
@@ -11,12 +11,14 @@
 # or not GitHub answers: each lifecycle event asks the port, and a refused ask is recorded on the
 # finding as a sync failure that a later run retries.
 #
-# An Adr is a decision record with its own lifecycle, linked to the finding it settles.
+# An Adr is a decision record with its own lifecycle, linked to the finding it settles. A Work is a
+# step of the plan a decision carries, and stays inside Hecks.
 Hecks.bluebook "Tickets" do
   vision "Track what Hecks needs, decide it, ship it, and drive GitHub from the record."
 
   aggregate "Finding" do
     description "One thing observed about Hecks that needs a decision or a fix: reported, triaged, then resolved or dismissed."
+    created_by "Finding.report!"
 
     attribute :finding,         FindingKey
     attribute :title,          Title
@@ -84,17 +86,12 @@ Hecks.bluebook "Tickets" do
     command "Report" do
       goal "Record something observed about Hecks as a finding"
 
-      attribute :finding,      FindingKey
-      attribute :title,       Title
-      attribute :body,        Body, optional: true
-      attribute :source,      Source
-      attribute :fingerprint, Fingerprint, optional: true
+      attribute :finding,      FindingKey, sets: true
+      attribute :title,       Title, sets: true
+      attribute :body,        Body, optional: true, sets: true
+      attribute :source,      Source, sets: true
+      attribute :fingerprint, Fingerprint, optional: true, sets: true
 
-      sets :finding
-      sets :title
-      sets :body
-      sets :source
-      sets :fingerprint
 
       emits "FindingReported"
     end
@@ -104,11 +101,9 @@ Hecks.bluebook "Tickets" do
     command "ReportFailedRun" do
       goal "Record a failed conformance or gate run as a finding"
 
-      attribute :finding, FindingKey
-      attribute :body,   Body
+      attribute :finding, FindingKey, sets: true
+      attribute :body,   Body, sets: true
 
-      sets :finding
-      sets :body
       sets :fingerprint, to: "run"
       sets :title,  to: "A Codebase run failed"
       sets :source, to: "qa_loop"
@@ -116,34 +111,14 @@ Hecks.bluebook "Tickets" do
       emits "RunFindingReported"
     end
 
-    # A lane that stood behind the lane it follows for longer than its Lane row allows reports
-    # itself. The alert key names the finding and carries the day, so a lane that stays late files
-    # one finding a day: the same key again is the same finding.
-    command "ReportLag" do
-      goal "Record a lane that has stood behind the lane it follows too long as a finding"
-
-      attribute :finding, FindingKey
-      attribute :body,    Body
-
-      sets :finding
-      sets :body
-      sets :fingerprint, to: "lane-lag"
-      sets :title,  to: "A lane is behind the lane it follows"
-      sets :source, to: "qa_loop"
-
-      emits "LagFindingReported"
-    end
-
     command "Triage" do
       role "Maintainer"
       goal "Give a finding its kind and severity"
 
       reference_to Finding
-      attribute :kind,     Kind
-      attribute :severity, Severity
+      attribute :kind,     Kind, sets: true
+      attribute :severity, Severity, sets: true
 
-      sets :kind
-      sets :severity
 
       emits "FindingTriaged"
     end
@@ -153,9 +128,8 @@ Hecks.bluebook "Tickets" do
       goal "Record the pull request that fixes a triaged finding"
 
       reference_to Finding
-      attribute :fix_pr_number, Number
+      attribute :fix_pr_number, Number, sets: true
 
-      sets :fix_pr_number
 
       emits "FixLinked"
     end
@@ -174,9 +148,8 @@ Hecks.bluebook "Tickets" do
       goal "Close a finding without a fix, with the reason"
 
       reference_to Finding
-      attribute :dismissal, Body
+      attribute :dismissal, Body, sets: true
 
-      sets :dismissal
 
       emits "FindingDismissed"
     end
@@ -192,22 +165,22 @@ Hecks.bluebook "Tickets" do
 
     command "RecordIssue" do
       goal "Record the GitHub issue number once the issue is opened"
+      audience :record
 
       reference_to Finding
-      attribute :issue_number, Number
+      attribute :issue_number, Number, sets: true
 
-      sets :issue_number
 
       emits "IssueRecorded"
     end
 
     command "RecordSyncFailure" do
       goal "Record that GitHub could not be driven, so a later run retries"
+      audience :record
 
       reference_to Finding
-      attribute :sync_failure, Body
+      attribute :sync_failure, Body, sets: true
 
-      sets :sync_failure
 
       emits "SyncFailed"
     end
@@ -221,11 +194,12 @@ Hecks.bluebook "Tickets" do
 
   aggregate "Adr" do
     description "A decision record: drafted, accepted, and possibly superseded, linked to the tickets it settles."
+    created_by "Adr.draft!"
 
     attribute :adr,       AdrNumber
     attribute :title,     AdrTitle
     attribute :supersedes, AdrNumber, optional: true
-    attribute :settles,   FindingKey, optional: true
+    reference_to Finding, as: :settles, optional: true
     identified_by :adr
 
     value_object "AdrNumber" do
@@ -238,25 +212,20 @@ Hecks.bluebook "Tickets" do
       invariant("a decision has a title") { !value.to_s.empty? }
     end
 
-    value_object "FindingKey" do
-      attribute :value, String, matches: :present
-    end
-
     lifecycle :status, default: "draft" do
       transition "Accept"    => "accepted",   from: "draft"
       transition "Supersede" => "superseded", from: "accepted"
+      mark :terminal, "superseded"
     end
 
     command "Draft" do
       role "Maintainer"
       goal "Open a decision record, optionally for the finding it settles"
 
-      attribute :adr,       AdrNumber
-      attribute :title,     AdrTitle
-      attribute :settles,   FindingKey, optional: true
+      attribute :adr,       AdrNumber, sets: true
+      attribute :title,     AdrTitle, sets: true
+      reference_to Finding, as: :settles, optional: true
 
-      sets :adr
-      sets :title
       sets :settles
 
       emits "AdrDrafted"
@@ -276,9 +245,8 @@ Hecks.bluebook "Tickets" do
       goal "Record that a later decision replaces this one"
 
       reference_to Adr
-      attribute :supersedes, AdrNumber
+      attribute :supersedes, AdrNumber, sets: true
 
-      sets :supersedes
 
       emits "AdrSuperseded"
     end
@@ -290,45 +258,318 @@ Hecks.bluebook "Tickets" do
     end
   end
 
+  # A step of a plan, held under the decision it carries out. It drives nothing outside: planned
+  # work is the maintainer's own list, not an issue.
+  aggregate "Work" do
+    description "One step of a plan: planned, started, then done or dropped, under the decision it carries out."
+    created_by "Work.plan!"
+
+    attribute :work,   WorkKey
+    attribute :title,  WorkTitle
+    attribute :detail, WorkText, optional: true
+    attribute :step,   Step, optional: true
+    attribute :reason, WorkText, optional: true
+    attribute :claimed_by, Claimant, optional: true
+    attribute :claimed_at, ClaimedAt, optional: true
+    attribute :area,   list_of(Word), optional: true
+    attribute :budget_minutes, Minutes, optional: true
+    reference_to Adr, as: :decision, optional: true
+    identified_by :work
+
+    # A path prefix or glob a claim covers. Two areas overlap by `Hecks::Adapters::AreaOverlap`;
+    # a row with no area claims nothing.
+    value_object "Word" do
+      attribute :value, String, matches: :present
+    end
+
+    # The session that claimed a started step, named as the session names itself. A step back in the
+    # plan holds the empty claimant; `Start` refuses one that names nobody.
+    value_object "Claimant" do
+      attribute :value, String, default: ""
+    end
+
+    # When the claim was taken, as the caller reads the clock: an ISO 8601 instant. Empty while the
+    # step is unclaimed.
+    value_object "ClaimedAt" do
+      attribute :value, String, default: ""
+    end
+
+    # How long a claim may run, in whole minutes. A row with none, or zero, has no budget; a step
+    # back in the plan holds zero.
+    value_object "Minutes" do
+      attribute :value, Integer
+
+      invariant("a time budget is not negative") { !value.negative? }
+    end
+
+    # What a query answered from outside the domain returns: its lines.
+    value_object "Document" do
+      attribute :text, String
+    end
+
+    value_object "WorkKey" do
+      attribute :value, String, matches: :present
+
+      invariant("a piece of work is named") { !value.to_s.empty? }
+    end
+
+    value_object "WorkTitle" do
+      attribute :value, String
+
+      invariant("a piece of work has a title") { !value.to_s.empty? }
+    end
+
+    value_object "WorkText" do
+      attribute :value, String
+    end
+
+    # Where the work stands in its plan: step 0 comes first.
+    value_object "Step" do
+      attribute :value, Integer
+
+      invariant("a step is not negative") { !value.negative? }
+    end
+
+    lifecycle :status, default: "planned" do
+      transition "Start"   => "started", from: "planned"
+      transition "Release" => "planned", from: "started"
+      transition "Yield"   => "planned", from: "started"
+      transition "Finish" => "done",    from: %w[planned started]
+      transition "Drop"   => "dropped", from: %w[planned started]
+      transition "Lapse"  => "dropped", from: %w[planned started]
+      transition "Reopen" => "planned", from: %w[done dropped]
+    end
+
+    command "Plan" do
+      role "Maintainer"
+      goal "Enter a step of a plan, optionally under the decision it carries out"
+
+      attribute :work,   WorkKey, sets: true
+      attribute :title,  WorkTitle, sets: true
+      # The detail and area default to none, so the event always carries them and
+      # ComposeBriefWhenPlanned in Coder can read them from any plan.
+      attribute :detail, WorkText, optional: true, sets: true, default: { value: "" }
+      attribute :step,   Step, optional: true, sets: true
+      attribute :area,   list_of(Word), optional: true, sets: true, default: []
+      reference_to Adr, as: :decision, optional: true
+
+      sets :decision
+
+      emits "WorkPlanned"
+    end
+
+    # A step still open takes what a later look at it found: the row stays one, its title and
+    # detail move.
+    command "Revise" do
+      goal "Replace an open step's title and detail with what a later look found"
+
+      reference_to Work
+      attribute :title,  WorkTitle, sets: true
+      attribute :detail, WorkText, sets: true
+
+      emits "WorkRevised"
+    end
+
+    # A started step is claimed: the second Start on it is refused, since only a planned step starts.
+    command "Start" do
+      role "Maintainer"
+      goal "Claim a planned step for one session, recording who claimed it and when"
+
+      reference_to Work
+      attribute :claimed_by, Claimant, sets: true
+      attribute :claimed_at, ClaimedAt, sets: true
+      attribute :area,       list_of(Word), optional: true, sets: true
+      attribute :budget_minutes, Minutes, optional: true, sets: true
+
+      given("a claim names its claimant") { !claimed_by.value.to_s.empty? }
+      given("a claim records when it was taken") { !claimed_at.value.to_s.empty? }
+
+      emits "WorkStarted"
+    end
+
+    # The claim's area overlapped another started step's, or it would start more steps than the
+    # cap allows: the WorkAreas or WorkLimits port refuses it by name, and the step goes back to
+    # the plan with the refusal as its reason.
+    command "Yield" do
+      goal "Return a step whose area another started step holds, with the refusal"
+
+      reference_to Work
+      attribute :reason, WorkText, sets: true
+
+      sets :claimed_by, to: ""
+      sets :claimed_at, to: ""
+      sets :area, to: []
+      sets :budget_minutes, to: 0
+
+      emits "WorkYielded"
+    end
+
+    # A claim gone stale returns its step to the plan, so the next session can claim it.
+    command "Release" do
+      goal "Return a started step to planned, releasing its claim"
+
+      reference_to Work
+
+      sets :claimed_by, to: ""
+      sets :claimed_at, to: ""
+      sets :area, to: []
+      sets :budget_minutes, to: 0
+
+      emits "WorkReleased"
+    end
+
+    command "Finish" do
+      role "Maintainer"
+      goal "Record that a step is done"
+
+      reference_to Work
+
+      emits "WorkFinished"
+    end
+
+    command "Drop" do
+      role "Maintainer"
+      goal "Set a step aside without doing it, with the reason"
+
+      reference_to Work
+      attribute :reason, WorkText, sets: true
+
+      emits "WorkDropped"
+    end
+
+    # A step whose cause came back (a spec red again after it was cleared) is planned again, with
+    # the new title and detail.
+    command "Reopen" do
+      goal "Return a finished or dropped step to planned because its cause returned"
+
+      reference_to Work
+      attribute :title,  WorkTitle, sets: true
+      attribute :detail, WorkText, optional: true, sets: true
+
+      emits "WorkReopened"
+    end
+
+    # A superseded decision's plan no longer stands, so its undone steps are dropped with it.
+    command "Lapse" do
+      goal "Drop a step whose decision was superseded"
+
+      reference_to Work
+
+      sets :reason, to: "its decision was superseded"
+
+      emits "WorkLapsed"
+    end
+
+    query "Undone" do
+      description "Every step not yet done or dropped, in plan order."
+      where(status: { in: "planned,started" })
+      order_by :step
+    end
+
+    # The first step still planned in plan order: the next one a coder session claims.
+    query "NextPlanned" do
+      description "The oldest step not yet claimed, in plan order: the brief a coder session reads next."
+      where(status: "planned")
+      order_by :step
+      limit 1
+    end
+
+    query "Under" do
+      description "Every step of the plan one decision carries, in plan order."
+      attribute :adr, String
+      where(decision: :adr)
+      order_by :step
+    end
+
+    query "UndoneUnder" do
+      description "The steps of one decision's plan not yet done or dropped: the ones its superseding drops."
+      attribute :adr, String
+      where(decision: :adr, status: { in: "planned,started" })
+      order_by :step
+    end
+  end
+
   # Each lifecycle event drives GitHub. A finding's own state never waits on the answer.
   policy "OpenIssueWhenReported" do
     on      "Finding.FindingReported"
-    trigger Finding::GitHubIssues::OpenIssue, with: { finding: :finding }
+    ask     :open_issue, with: { finding: :finding }
   end
 
   policy "OpenIssueWhenRunReported" do
     on      "Finding.RunFindingReported"
-    trigger Finding::GitHubIssues::OpenIssue, with: { finding: :finding }
-  end
-
-  policy "OpenIssueWhenLagReported" do
-    on      "Finding.LagFindingReported"
-    trigger Finding::GitHubIssues::OpenIssue, with: { finding: :finding }
+    ask     :open_issue, with: { finding: :finding }
   end
 
   policy "LabelIssueWhenTriaged" do
     on      "Finding.FindingTriaged"
-    trigger Finding::GitHubIssues::LabelIssue, with: { finding: :finding }
+    ask     :label_issue, with: { finding: :finding }
   end
 
   policy "CommentWhenFixLinked" do
     on      "Finding.FixLinked"
-    trigger Finding::GitHubIssues::CommentOnIssue, with: { finding: :finding }
+    ask     :comment_on_issue, with: { finding: :finding }
   end
 
   policy "CloseIssueWhenResolved" do
     on      "Finding.FindingResolved"
-    trigger Finding::GitHubIssues::CloseIssue, with: { finding: :finding }
+    ask     :close_issue, with: { finding: :finding }
   end
 
   policy "CloseIssueWhenDismissed" do
     on      "Finding.FindingDismissed"
-    trigger Finding::GitHubIssues::CloseIssue, with: { finding: :finding }
+    ask     :close_issue, with: { finding: :finding }
   end
 
   policy "ReopenIssueWhenReopened" do
     on      "Finding.FindingReopened"
-    trigger Finding::GitHubIssues::ReopenIssue, with: { finding: :finding }
+    ask     :reopen_issue, with: { finding: :finding }
+  end
+
+  # A started step with an area asks the WorkAreas port whether another started step holds any of it.
+  policy "CheckAreaWhenStarted" do
+    on      "Work.WorkStarted"
+    ask     :check_area, with: { work: :work }
+  end
+
+  policy "YieldWhenAreaTaken" do
+    on      "Work.AreaRefused"
+    trigger Work::Yield, with: { reason: :refusal }
+  end
+
+  # A started step asks the WorkLimits port whether it is one too many for the concurrency cap. It is
+  # declared after the area check, so a step that clashes is already back in the plan when the cap
+  # looks, and the cap yields only a step still started.
+  policy "CheckCapWhenStarted" do
+    on      "Work.WorkStarted"
+    ask     :check_cap, with: { work: :work }
+  end
+
+  policy "YieldWhenCapReached" do
+    on      "Work.CapRefused"
+    trigger Work::Yield, with: { reason: :refusal }
+  end
+
+  # A superseded decision takes its undone steps with it.
+  policy "LapseWorkWhenSuperseded" do
+    on       "Adr.AdrSuperseded"
+    for_each "Work.UndoneUnder"
+    trigger  Work::Lapse, with: { work: :work }
+  end
+
+  # A coder's submitted branch is named for its work step, so the branch is the step's key and the
+  # policy routes it with no parsing (`with:` only routes fields). A branch naming no step is refused
+  # by the Finish command: the refusal names Work.
+  policy "FinishWhenWorkSubmitted" do
+    on      "Submission.WorkSubmitted"
+    trigger Work::Finish, with: { work: :branch }
+  end
+
+  # A branch that landed on local main finishes the step it was cut for. The Landing's LandedWork
+  # port found the open step the branch names (the whole branch name, else the name without a leading
+  # `qa/`) and answered its key; a branch with no open step is refused there and never reaches here.
+  policy "FinishWorkWhenBranchLanded" do
+    on      "Landing.LandedWorkFound"
+    trigger Work::Finish, with: { work: :branch }
   end
 
   # A conformance or gate run that faults files its own finding.
@@ -337,17 +578,50 @@ Hecks.bluebook "Tickets" do
     trigger Finding::ReportFailedRun, with: { finding: :run, body: :refusal }
   end
 
-  # A watch that finds a lane late faults it, and the fault files its finding.
-  policy "ReportWhenLaneLags" do
-    on      "PromotionRun.LaneLagged"
-    trigger Finding::ReportLag, with: { finding: :alert_key, body: :refusal }
-  end
-
   policy "ReportWhenGateFaulted" do
     on      "GateRun.GateFaulted"
     trigger Finding::ReportFailedRun, with: { finding: :run, body: :refusal }
   end
 
+  # A spec file that went red on main is a step QA picks up: `Work.undone` lists it. The spec's own key is
+  # the step's key, so a second red run, which only updates the spec, plans nothing twice.
+  policy "PlanWorkWhenSpecWentRed" do
+    on      "RedSpec.SpecWentRed"
+    trigger Work::Plan, with: { work: :spec, title: :title, detail: :detail }
+  end
+
+  # A file that fails again after it was cleared plans its finished step again.
+  policy "ReopenWorkWhenSpecWentRedAgain" do
+    on      "RedSpec.SpecWentRedAgain"
+    trigger Work::Reopen, with: { work: :spec, title: :title, detail: :detail }
+  end
+
+  # The run that no longer fails the file closes its step.
+  policy "FinishWorkWhenSpecWentGreen" do
+    on      "RedSpec.SpecWentGreen"
+    trigger Work::Finish, with: { work: :spec }
+  end
+
+  # QA's push check: a push that is due beyond the world's thresholds is one step, `push-due`. A look
+  # that finds it already open revises its detail; a look that finds it no longer due finishes it.
+  policy "PlanWorkWhenPushDue" do
+    on      "PushNudge.PushDueRead"
+    where   { due.value == "yes" && raised.value == "no" }
+    trigger Work::Plan, with: { work: :work, title: :title, detail: :detail }
+  end
+
+  policy "ReviseWorkWhenPushStillDue" do
+    on      "PushNudge.PushDueRead"
+    where   { due.value == "yes" && raised.value == "yes" }
+    trigger Work::Revise, with: { work: :work, title: :title, detail: :detail }
+  end
+
+  policy "FinishWorkWhenPushSettled" do
+    on      "PushNudge.PushDueRead"
+    where   { due.value == "no" && raised.value == "yes" }
+    trigger Work::Finish, with: { work: :work }
+  end
+
   policy "RecordTheIssue" do
     on      "Finding.IssueOpened"
     trigger Finding::RecordIssue, with: { issue_number: :issue_number }

data/lib/hecks/tickets/bluebook/tickets.hecksagon

@@ -3,9 +3,16 @@
 Hecks.hecksagon "Tickets" do
   attaches "Governance"
   persisted_by "Memory"
+
+  # The coder's submitted branch, which finishes its work step. Declarative: the Coder domain
+  # emits it, and the FinishWhenWorkSubmitted policy reacts.
+  subscribe "Coder.WorkSubmitted"
+
+  # The Hecks domain's landing found the step a landed branch was cut for: FinishWorkWhenBranchLanded reacts.
+  subscribe "Hecks.LandedWorkFound"
 end
 
-# The anti-corruption layer for Governance, which the chapter's roles are checked against.
+# The anti-corruption layer for Governance, which the bluebook's roles are checked against.
 Hecks.hecksagon "Governance" do
   persisted_by "Memory"
 end

data/lib/hecks/tickets/bluebook/tickets.ports.hecksagon

@@ -1,4 +1,4 @@
-# The port Tickets declares, for every hecksagon that attaches the chapter (`Chapters` loads this
+# The port Tickets declares, for every hecksagon that attaches the bluebook (`Bluebooks` loads this
 # file with it). Each lifecycle event of a finding asks the GitHubIssues port, which the Hecks domain
 # binds (lib/hecks/hecks/adapters/finding_github.rb): the outside a finding reaches. The ask is
 # answered with the record's own arguments or refused with a reason, and a refusal is recorded on the
@@ -23,4 +23,21 @@ Hecks.hecksagon "Tickets" do
       end
     end
   end
+  Tickets::Work.port "WorkAreas" do
+    asks "CheckArea", to: Work do
+      attribute :work, WorkKey
+      answers "AreaCleared"
+      refuses "AreaRefused"
+    end
+  end
+
+  # The cap on started rows, which reads the other rows, as a bluebook rule cannot. The cap is the
+  # world's `work_limit` setting.
+  Tickets::Work.port "WorkLimits" do
+    asks "CheckCap", to: Work do
+      attribute :work, WorkKey
+      answers "CapCleared"
+      refuses "CapRefused"
+    end
+  end
 end

data/lib/hecks/tools/argument_gate_matrix/dispatching.rb

@@ -55,7 +55,7 @@ module Hecks
           dispatch_row(runtime, row, args)
           [nil, nil, nil]
         rescue *Hecks::Runtime::DOMAIN_REFUSALS => e
-          [e.class.name.split("::").last, e.message, refused_step(kind)]
+          [Hecks::Naming.demodulise(e.class), e.message, refused_step(kind)]
         end
 
         def dispatch_row(runtime, row, args)

data/lib/hecks/tools/argument_gate_matrix/rows.rb

@@ -92,24 +92,24 @@ module Hecks
           Violations::MISMATCHED_ROLE if [earlier, later].include?("refuse_role_mismatch")
         end
 
-        def candidates(runtime, chapter)
-          bluebook = runtime.registry.bluebook(chapter)
+        def candidates(runtime, declaration)
+          bluebook = runtime.bluebook(declaration)
           random = SteadyRandom.new(20_260_918)
           bluebook.aggregates.flat_map do |aggregate|
-            aggregate_rows(aggregate, chapter, random) + entity_rows(aggregate, chapter, random)
+            aggregate_rows(aggregate, declaration, random) + entity_rows(aggregate, declaration, random)
           end
         end
 
-        def aggregate_rows(aggregate, chapter, random)
+        def aggregate_rows(aggregate, declaration, random)
           aggregate.commands.flat_map do |command|
-            rows_for(command, aggregate, "#{chapter}::#{aggregate.hecks_name}.#{command.hecks_name}", "aggregate", random)
+            rows_for(command, aggregate, "#{declaration}::#{aggregate.hecks_name}.#{command.hecks_name}", "aggregate", random)
           end
         end
 
-        def entity_rows(aggregate, chapter, random)
+        def entity_rows(aggregate, declaration, random)
           aggregate.entities.flat_map do |entity|
             entity.commands.flat_map do |command|
-              verb = "#{chapter}::#{aggregate.hecks_name}.#{entity.hecks_name}.#{command.hecks_name}"
+              verb = "#{declaration}::#{aggregate.hecks_name}.#{entity.hecks_name}.#{command.hecks_name}"
               rows = rows_for(command, aggregate, verb, "entity", random)
               rows.each { |row| row[:args] = identity_args(entity, aggregate, random).merge(row[:args]) }
             end

data/lib/hecks/tools/argument_gate_matrix/violations.rb

@@ -99,7 +99,7 @@ module Hecks
         def violate_reference!(args, command)
           reference = command.attributes.find(&:reference?) or return nil
 
-          args[reference.name.to_s] = "no-such-#{reference.type.target_name.to_s.downcase}"
+          args[reference.name.to_s] = "no-such-#{reference.target_name.to_s.downcase}"
           reference.name.to_s
         end
       end