hecks 3.0.5 → 3.1.1

data/lib/hecks/three_zero/forms.yml

@@ -1,127 +1,127 @@
 # Each bin/ script and exe/hecks route, and the hecks 3.0 form that replaces it: the verb spelling the
 # 3.0 launcher answers to (ADR 0080, section 7), with QualityControl verbs after `hecks quality_control`.
 ---
-argument_gate_matrix: hecks argument_gate_matrix [--confirm] (writes only with --confirm)
-backfill_era_projections: hecks backfill_projections <domain>
-behaviors: hecks run_behaviors subject=<path>
-bench: hecks bench [domains=pizzas,banking] [targets=] [iterations=1000] [warmup=200]
+argument_gate_matrix: hecks conformance_run.argument_gate_matrix [--confirm] (writes only with --confirm)
+backfill_era_projections: hecks era.backfill_projections <domain>
+behaviors: hecks operation.run_behaviors subject=<path>
+bench: hecks fuzz_run.bench [domains=pizzas,banking] [targets=] [iterations=1000] [warmup=200]
   [runs=3] [rust_binary=] [format=markdown] [output=]
-canonicalise: hecks canonicalise <file.json>
-check_engine_agreement: hecks check_engine_agreement
-check_era: hecks check_era <url> expected=era-file [timeout=10]
-codemod_hoist_local_givens: hecks hoist_local_givens --confirm
-codemod_implicit_append_fields: hecks drop_implicit_append_fields --confirm
-compact: hecks compact <domain> [aggregates=A,B] --confirm
+canonicalise: hecks style_run.canonicalise <file.json>
+check_engine_agreement: hecks conformance_run.check_engine_agreement
+check_era: hecks host.check_era <url> expected=era-file [timeout=]
+codemod_hoist_local_givens: hecks codemod_run.hoist_local_givens --confirm
+codemod_implicit_append_fields: hecks codemod_run.drop_implicit_append_fields --confirm
+compact: hecks era.compact <domain> [aggregates=A,B] --confirm
 console: hecks console [subject=<domain>]
-corpus: hecks rust_domains; hecks regen_order; hecks corpus_rust_coverage
-deploy_template_diff: hecks deploy diff before=a.yaml after=b.yaml [--json] [--strict]
-doc_coverage: hecks measure_doc_coverage
+corpus: hecks corpus_run.rust_domains; hecks corpus_run.regen_order; hecks corpus_run.corpus_rust_coverage
+deploy_template_diff: hecks deploy template_comparison.diff before=a.yaml after=b.yaml [--json] [--strict]
+doc_coverage: hecks conformance_run.measure_doc_coverage
 docs: hecks docs [domain-path] [aggregate]
-evolve: hecks word_status; hecks propose <word> context=X [body=none] [inner=] [opens=]
-  [fills=]; hecks admit|deprecate|retire <word> context=X; hecks rename <word> context=X
-  new_name=Y; hecks propose_argument <word> context=X kind=K [required=false] [at=N]
-  [named=] [fills=] [pairs_shape=]; hecks admit_argument|deprecate_argument|retire_argument
+evolve: hecks language_run.word_status; hecks language_run.propose <word> context=X [body=none] [inner=] [opens=]
+  [fills=]; hecks language_run.admit|deprecate|retire <word> context=X; hecks language_run.rename <word> context=X
+  new_name=Y; hecks language_run.propose_argument <word> context=X kind=K [required=false] [at=N]
+  [named=] [fills=] [pairs_shape=]; hecks language_run.admit_argument|deprecate_argument|retire_argument
   <word> context=X [at=N] [named=]
-expression_projection: hecks project_expression_tables [--stdout]
-follow: hecks follow <domain> [aggregate=Name] [since=N] [interval=0.5] [wait=N] [--from-now] [--stream]
-fuzz: hecks fuzz [domain] [seeds=20] [steps=30] [workers=] [adapter=memory]
-generate: hecks generate_sequence <domain> [seed=1] [steps=30] [adversarial=0.0]
+expression_projection: hecks language_run.project_expression_tables [--stdout]
+follow: hecks operation.follow <domain> [aggregate=Name] [since=N] [interval=0.5] [wait=N] [--from-now] [--stream]
+fuzz: hecks fuzz_run.fuzz [domain] [seeds=20] [steps=30] [workers=] [adapter=memory]
+generate: hecks fuzz_run.generate_sequence <domain> [seed=1] [steps=30] [adversarial=0.0]
 hecks_mcp_door: hecks mcp [--stdio]
-hecks_query_ir_mcp: hecks serve_query_ir_mcp
-heki_compact: hecks compact_heki <domain> [aggregates=A,B] --confirm
-history: hecks history <domain>
+hecks_query_ir_mcp: hecks corpus_run.serve_query_ir_mcp
+heki_compact: hecks era.compact_heki <domain> [aggregates=A,B] --confirm
+history: hecks introspection.history <domain>
 ir: hecks ir <domain> [--translations] | hecks ir --meta
-lint_deploy_recipes: hecks deploy lint [makefiles=a,b]
-merge_tail: hecks merge_tail <domain> winners=id:old,id:new --confirm
+lint_deploy_recipes: hecks deploy makefile_check.lint [makefiles=a,b]
+merge_tail: hecks era.merge_tail <domain> winners=id:old,id:new --confirm
 model_check: hecks model_check [--strict] [--profile client] [<domain> …]
 narrate: hecks narrate [domain-path] [aggregate]
-pattern-cases: hecks record_pattern_cases
-present: hecks present [port=4567]
-project: hecks refresh_projections subject=<domain>
-project_bootstrap_table: hecks project_bootstrap_table
+pattern-cases: hecks test_suite_run.record_pattern_cases
+present: hecks corpus_run.present [port=4567]
+project: hecks operation.refresh_projections subject=<domain>
+project_bootstrap_table: hecks language_run.project_bootstrap_table
 project_cli: hecks project_cli [domain-path …]
-project_deploy: hecks deploy project <domain> [tenant=] [schema=] [out=] [environment=]
+project_deploy: hecks deploy recipe.project <domain> [tenant=] [schema=] [out=] [environment=]
 project_diagrams: hecks project_diagrams <domain-path> <ChapterName>
-project_field_hints: hecks project_field_hints
-project_glossary: hecks glossary <domain> chapter=Name
-project_kernel_capabilities: hecks project_kernel_capabilities
-project_model: hecks project_model
-project_oidc: hecks deploy project_oidc [domains=a,b]
-project_parser_table: hecks project_parser_table
-project_refusal_wording: hecks project_refusal_wording
-project_reserved_names: hecks project_reserved_names
-project_rust: hecks project_rust <domain>
-project_rust_vocabulary: hecks project_rust_vocabulary
-project_tenant: hecks deploy provision <domain_dir> slug=s domain= realm= schema=
-  database= [adapter=PostgresEra]; hecks deploy reprovision <tenant> directory= database=
+project_field_hints: hecks language_run.project_field_hints
+project_glossary: hecks introspection.glossary <domain> chapter=Name
+project_kernel_capabilities: hecks kernel_run.project_kernel_capabilities
+project_model: hecks language_run.project_model
+project_oidc: hecks deploy oidc_manifest.project_oidc [domains=a,b]
+project_parser_table: hecks language_run.project_parser_table
+project_refusal_wording: hecks language_run.project_refusal_wording
+project_reserved_names: hecks language_run.project_reserved_names
+project_rust: hecks build.project_rust <domain>
+project_rust_vocabulary: hecks language_run.project_rust_vocabulary
+project_tenant: hecks deploy tenant.provision <domain_dir> slug=s domain= realm= schema=
+  database= [adapter=PostgresEra]; hecks deploy tenant.reprovision <tenant> directory= database=
   [adapter=PostgresEra]
-project_vocabulary: hecks project_vocabulary
-project_wasm: hecks build_wasm <domain>
-project_wasm_browser: hecks build_browser_wasm <domain>
+project_vocabulary: hecks language_run.project_vocabulary
+project_wasm: hecks build.build_wasm <domain>
+project_wasm_browser: hecks build.build_browser_wasm <domain>
 qa_concurrency_racer: not user-facing; ProcessPool starts it as hecks quality_control
-  race domain= database= schema= verb= step_arguments=
-qa_discover_external_domains: hecks quality_control discover_external_domains [arguments="--projects-dir
+  sweep.race domain= database= schema= verb= step_arguments=
+qa_discover_external_domains: hecks quality_control target.discover_external_domains [arguments="--projects-dir
   ~/Projects --max-depth 3 --known-path PATH …"]
-qa_domain_novelty: hecks quality_control judge_novelty <domain> [arguments="--against
+qa_domain_novelty: hecks quality_control target.judge_novelty <domain> [arguments="--against
   PATH …"]
-qa_generated_domains: hecks quality_control check_generated_domains [arguments="--domains
+qa_generated_domains: hecks quality_control target.check_generated_domains [arguments="--domains
   3 --start N --forms a,b --seeds 5 --steps 25 --adversarial 0.3 --rust --shrink-budget
   200 --domain-shrink-budget 40 --promote dir --name N --from-dials --blueprint F
   --source F"]
-qa_log_bug: hecks quality_control log sweep=<sweep id> reference= sequence=N title=
+qa_log_bug: hecks quality_control bug.log sweep=<sweep id> reference= sequence=N title=
   demonstration= symptom= expectation= submitter= [tags=a,b] [name=] [reproduced=yes|no]
-qa_mine_combinations: hecks quality_control mine_combinations [arguments="--candidates
+qa_mine_combinations: hecks quality_control target.mine_combinations [arguments="--candidates
   3 --rust --seeds 5 --steps 25 --adversarial 0.3 --repair-rounds 1 --agent CMD --from
   DIR --against PATH --brief"]
 qa_open_pr: hecks quality_control patch.open bug=BUG#n number=N url=… branch=… commit=SHA
   title=… [now=]; hecks quality_control improvement.open [angle=ANGLE-n] number=N
   url=… branch=… title=… [now=]
-qa_postgres_migrate: hecks quality_control migrate_ledger_from_heki domain=<domain_dir>
+qa_postgres_migrate: hecks quality_control sweep.migrate_ledger_from_heki domain=<domain_dir>
   data=<heki_dir> [arguments="[aggregate …] --force"] (a dry run without --force)
-qa_postgres_role: hecks quality_control create_ledger_role <database> [role=hecks_qa]
-qa_pr_check: hecks quality_control check_pull_requests
+qa_postgres_role: hecks quality_control sweep.create_ledger_role <database> [role=hecks_qa]
+qa_pr_check: hecks quality_control clearance.check_pull_requests
 qa_seed_angles: hecks quality_control angle.seed
 qa_seed_targets: hecks quality_control target.seed
-qa_sweep: hecks quality_control ask run [target=] [arguments="--all --seeds N --steps
+qa_sweep: hecks quality_control query sweep.run [target=] [arguments="--all --seeds N --steps
   N --adversarial F --role-draw F --dry-run F --self-consistency BOOL --modes a,b
-  --persistence-parity --no-parity"]; hecks quality_control release <target> [now=]
+  --persistence-parity --no-parity"]; hecks quality_control target.release <target> [now=]
   [next_streak=] [capabilities=] [yield_score=]
-qa_tick: hecks quality_control tick
-query_ir: hecks ir_constructs [names=a,b]; hecks ir_duplicates [domains=a,b] [--meta];
-  hecks ir_impact name=N field=F
-reattest_era: hecks reattest <domain> era=N --confirm
-reference: hecks project_reference
-refresh_rspec_runtime_baseline: hecks refresh_runtime_baseline [workers=6] [from_run=ID]
-regen_codegen_domains: hecks regenerate_corpus [--check]
-regenerate_persistence_legacy_fixtures: hecks regenerate_legacy_fixtures --confirm
-release: hecks publish [--gem-only] [--npm-only] [--npm-local] [--no-wait] --confirm
+qa_tick: hecks quality_control sweep.tick
+query_ir: hecks corpus_run.ir_constructs [names=a,b]; hecks corpus_run.ir_duplicates [domains=a,b] [--meta];
+  hecks corpus_run.ir_impact name=N field=F
+reattest_era: hecks era.reattest <domain> era=N --confirm
+reference: hecks language_run.project_reference
+refresh_rspec_runtime_baseline: hecks test_suite_run.refresh_runtime_baseline [workers=] [from_run=ID]
+regen_codegen_domains: hecks regeneration_run.regenerate_corpus [--check]
+regenerate_persistence_legacy_fixtures: hecks test_suite_run.regenerate_legacy_fixtures --confirm
+release: hecks publishing_run.publish [--gem-only] [--npm-only] [--npm-local] [--no-wait] --confirm
   (without --confirm, the old --dry-run)
-release_gem: hecks publish_gem --confirm
-rspec_io_parallel_files: hecks list_io_parallel_specs exclude=REGEX [tags=] [check=file];
-  hecks write_io_parallel_spec_list exclude=REGEX [tags=] write=file --confirm
-rspec_shard_files: hecks shard_specs group=1 groups=N [runtime_log=]
+release_gem: hecks publishing_run.publish_gem --confirm
+rspec_io_parallel_files: hecks test_suite_run.list_io_parallel_specs exclude=REGEX [tags=] [check=file];
+  hecks test_suite_run.write_io_parallel_spec_list exclude=REGEX [tags=] write=file --confirm
+rspec_shard_files: hecks test_suite_run.shard_specs group=1 groups=N [runtime_log=]
 run: hecks run [domain] <verb [name=value …] | script.json | - | '{"steps":[…]}'>
-rust_conformance: hecks check_conformance <domain> script=steps.json [artifact=native]
-rust_conformance_fuzz: hecks fuzz_conformance <domain> artifact=native [seeds=10]
+rust_conformance: hecks build.check_conformance <domain> script=steps.json [artifact=native]
+rust_conformance_fuzz: hecks build.fuzz_conformance <domain> artifact=native [seeds=10]
   [steps=25]
-rust_coverage: hecks rust_coverage <module> [codegen=ruby]; hecks check_coverage_allowlist
-rust_kernel_coverage: hecks measure_kernel_coverage
-scaffold_translation: hecks scaffold_translation <domain>
-seed_semantics_corpus: hecks seed_semantics_corpus [fixture=name]
-shape: hecks shape <domain>
-smoke_http: hecks smoke_http path=/p [url=] [header=] [scheme=timestamped]
+rust_coverage: hecks build.rust_coverage <module> [codegen=ruby]; hecks build.check_coverage_allowlist
+rust_kernel_coverage: hecks kernel_run.measure_kernel_coverage
+scaffold_translation: hecks era.scaffold_translation <domain>
+seed_semantics_corpus: hecks test_suite_run.seed_semantics_corpus [fixture=name]
+shape: hecks introspection.shape <domain>
+smoke_http: hecks operation.smoke_http path=/p [url=] [header=] [scheme=timestamped]
   [payload=] [payload_file=] [health_path=] [state_path=]
 smoke_test: hecks smoke_test [domain]
-spec_example: hecks run_spec_example file=path example=text
-standardize_comments: hecks report_comments paths=a,b [only=] [--json] [top=20]; hecks
-  check_comments paths=…; hecks fix_comments paths=… --confirm; hecks write_comment_baseline
-  --confirm; hecks check_comments_unchanged ref=REF
-standardize_comments_rust: hecks report_rust_comments paths=a,b [only=] [--json] [top=N];
-  hecks check_rust_comments paths=… [only=]; hecks fix_rust_comments paths=… [only=]
+spec_example: hecks test_suite_run.run_spec_example file=path example=text
+standardize_comments: hecks style_run.report_comments paths=a,b [only=] [--json] [top=20]; hecks
+  style_run.check_comments paths=…; hecks style_run.fix_comments paths=… --confirm; hecks style_run.write_comment_baseline
+  --confirm; hecks style_run.check_comments_unchanged ref=REF
+standardize_comments_rust: hecks style_run.report_rust_comments paths=a,b [only=] [--json] [top=N];
+  hecks style_run.check_rust_comments paths=… [only=]; hecks style_run.fix_rust_comments paths=… [only=]
   --confirm
-statements: hecks statements <domain> chapter=Name
+statements: hecks introspection.statements <domain> chapter=Name
 stores: hecks stores <domain>
-stress_concurrency_specs: hecks stress_concurrency [runs=30] [parallel=] [seed_start=1]
-translation_audit: hecks audit_translation <domain>; hecks approve_translation <domain>
+stress_concurrency_specs: hecks test_suite_run.stress_concurrency [runs=] [parallel=] [seed_start=]
+translation_audit: hecks era.audit_translation <domain>; hecks era.approve_translation <domain>
   [snapshot=] [host_version=] [rehearsal=pass|fail] [rehearsed_at=] --confirm
-vendor_bluebook: hecks vendor <package[@version]> [from=path] [root=path]
+vendor_bluebook: hecks package.vendor <package[@version]> [from=path] [root=path]

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

@@ -0,0 +1,331 @@
+# The Tickets chapter: 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
+# Hecks domain has its own Release, the record of a gem version. A Finding sits before both: it is
+# any observation, not yet a proven bug, and it needs no sweep or failing test to be recorded.
+#
+# A Finding is the record. A gap, a parity divergence, a QA finding and an idea are kinds of it, not
+# separate aggregates. Hecks owns the finding's state; GitHub is driven from it through the
+# GitHubIssues port, which a hecksagon binds (nothing here reads GitHub back). A finding exists whether
+# 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.
+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."
+
+    attribute :finding,         FindingKey
+    attribute :title,          Title
+    attribute :body,           Body, optional: true
+    attribute :kind,           Kind, optional: true
+    attribute :severity,       Severity, optional: true
+    attribute :source,         Source
+    attribute :fingerprint,    Fingerprint, optional: true
+    attribute :issue_number,   Number, optional: true
+    attribute :fix_pr_number,  Number, optional: true
+    attribute :dismissal,      Body, optional: true
+    attribute :sync_failure,   Body, optional: true
+    identified_by :finding
+
+    value_object "FindingKey" do
+      attribute :value, String, pattern: '[^ \t\n\r]'
+
+      invariant("a finding is named") { !value.to_s.empty? }
+    end
+
+    value_object "Title" do
+      attribute :value, String
+
+      invariant("a finding has a title") { !value.to_s.empty? }
+    end
+
+    value_object "Body" do
+      attribute :value, String
+    end
+
+    # What the finding is: a `gap` Hecks cannot yet express, a `parity` divergence between the Ruby
+    # and Rust runtimes, a `qa` finding from the QA loop, or an `idea`.
+    value_object "Kind" do
+      attribute :value, String, one_of: ["gap", "parity", "qa", "idea"]
+    end
+
+    value_object "Severity" do
+      attribute :value, String, one_of: ["low", "medium", "high"]
+    end
+
+    # Where it came from: the QA loop, work for a client, a parity check, or a maintainer by hand.
+    value_object "Source" do
+      attribute :value, String, one_of: ["qa_loop", "client_work", "parity_check", "maintainer"]
+    end
+
+    # The same finding refiled by the QA loop carries the same fingerprint, so a report of it while an
+    # open finding holds it changes nothing.
+    value_object "Fingerprint" do
+      attribute :value, String, pattern: '[^ \t\n\r]'
+    end
+
+    value_object "Number" do
+      attribute :value, Integer
+
+      invariant("a number is positive") { value.positive? }
+    end
+
+    lifecycle :status, default: "reported" do
+      transition "Triage"  => "triaged",   from: %w[reported triaged]
+      transition "Resolve" => "resolved",  from: "triaged"
+      transition "Dismiss" => "dismissed", from: %w[reported triaged]
+      transition "Reopen"  => "triaged",   from: %w[resolved dismissed]
+    end
+
+    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
+
+      sets :finding
+      sets :title
+      sets :body
+      sets :source
+      sets :fingerprint
+
+      emits "FindingReported"
+    end
+
+    # A failed Codebase run reports itself: the run's key names the finding and doubles as its
+    # fingerprint, so the same run failing again while its finding is open changes nothing.
+    command "ReportFailedRun" do
+      goal "Record a failed conformance or gate run as a finding"
+
+      attribute :finding, FindingKey
+      attribute :body,   Body
+
+      sets :finding
+      sets :body
+      sets :fingerprint, to: "run"
+      sets :title,  to: "A Codebase run failed"
+      sets :source, to: "qa_loop"
+
+      emits "RunFindingReported"
+    end
+
+    command "Triage" do
+      role "Maintainer"
+      goal "Give a finding its kind and severity"
+
+      reference_to Finding
+      attribute :kind,     Kind
+      attribute :severity, Severity
+
+      sets :kind
+      sets :severity
+
+      emits "FindingTriaged"
+    end
+
+    command "LinkFix" do
+      role "Maintainer"
+      goal "Record the pull request that fixes a triaged finding"
+
+      reference_to Finding
+      attribute :fix_pr_number, Number
+
+      sets :fix_pr_number
+
+      emits "FixLinked"
+    end
+
+    command "Resolve" do
+      role "Maintainer"
+      goal "Close a triaged finding as resolved"
+
+      reference_to Finding
+
+      emits "FindingResolved"
+    end
+
+    command "Dismiss" do
+      role "Maintainer"
+      goal "Close a finding without a fix, with the reason"
+
+      reference_to Finding
+      attribute :dismissal, Body
+
+      sets :dismissal
+
+      emits "FindingDismissed"
+    end
+
+    command "Reopen" do
+      role "Maintainer"
+      goal "Take a resolved or dismissed finding back to triaged, as when a fix regresses"
+
+      reference_to Finding
+
+      emits "FindingReopened"
+    end
+
+    command "RecordIssue" do
+      goal "Record the GitHub issue number once the issue is opened"
+
+      reference_to Finding
+      attribute :issue_number, Number
+
+      sets :issue_number
+
+      emits "IssueRecorded"
+    end
+
+    command "RecordSyncFailure" do
+      goal "Record that GitHub could not be driven, so a later run retries"
+
+      reference_to Finding
+      attribute :sync_failure, Body
+
+      sets :sync_failure
+
+      emits "SyncFailed"
+    end
+
+    query "Open" do
+      description "Every finding not yet resolved or dismissed."
+      where(status: { in: "reported,triaged" })
+      order_by :finding
+    end
+  end
+
+  aggregate "Adr" do
+    description "A decision record: drafted, accepted, and possibly superseded, linked to the tickets it settles."
+
+    attribute :adr,       AdrNumber
+    attribute :title,     AdrTitle
+    attribute :supersedes, AdrNumber, optional: true
+    attribute :settles,   FindingKey, optional: true
+    identified_by :adr
+
+    value_object "AdrNumber" do
+      attribute :value, String, pattern: '\A[0-9]{4}\z'
+    end
+
+    value_object "AdrTitle" do
+      attribute :value, String
+
+      invariant("a decision has a title") { !value.to_s.empty? }
+    end
+
+    value_object "FindingKey" do
+      attribute :value, String, pattern: '[^ \t\n\r]'
+    end
+
+    lifecycle :status, default: "draft" do
+      transition "Accept"    => "accepted",   from: "draft"
+      transition "Supersede" => "superseded", from: "accepted"
+    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
+
+      sets :adr
+      sets :title
+      sets :settles
+
+      emits "AdrDrafted"
+    end
+
+    command "Accept" do
+      role "Maintainer"
+      goal "Record that the decision was accepted"
+
+      reference_to Adr
+
+      emits "AdrAccepted"
+    end
+
+    command "Supersede" do
+      role "Maintainer"
+      goal "Record that a later decision replaces this one"
+
+      reference_to Adr
+      attribute :supersedes, AdrNumber
+
+      sets :supersedes
+
+      emits "AdrSuperseded"
+    end
+
+    query "Standing" do
+      description "Every decision that is accepted and not superseded."
+      where(status: "accepted")
+      order_by :adr
+    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 }
+  end
+
+  policy "OpenIssueWhenRunReported" do
+    on      "Finding.RunFindingReported"
+    trigger Finding::GitHubIssues::OpenIssue, with: { finding: :finding }
+  end
+
+  policy "LabelIssueWhenTriaged" do
+    on      "Finding.FindingTriaged"
+    trigger Finding::GitHubIssues::LabelIssue, with: { finding: :finding }
+  end
+
+  policy "CommentWhenFixLinked" do
+    on      "Finding.FixLinked"
+    trigger Finding::GitHubIssues::CommentOnIssue, with: { finding: :finding }
+  end
+
+  policy "CloseIssueWhenResolved" do
+    on      "Finding.FindingResolved"
+    trigger Finding::GitHubIssues::CloseIssue, with: { finding: :finding }
+  end
+
+  policy "CloseIssueWhenDismissed" do
+    on      "Finding.FindingDismissed"
+    trigger Finding::GitHubIssues::CloseIssue, with: { finding: :finding }
+  end
+
+  policy "ReopenIssueWhenReopened" do
+    on      "Finding.FindingReopened"
+    trigger Finding::GitHubIssues::ReopenIssue, with: { finding: :finding }
+  end
+
+  # A conformance or gate run that faults files its own finding.
+  policy "ReportWhenConformanceFaulted" do
+    on      "ConformanceRun.ConformanceFaulted"
+    trigger Finding::ReportFailedRun, with: { finding: :run, body: :refusal }
+  end
+
+  policy "ReportWhenGateFaulted" do
+    on      "GateRun.GateFaulted"
+    trigger Finding::ReportFailedRun, with: { finding: :run, body: :refusal }
+  end
+
+  policy "RecordTheIssue" do
+    on      "Finding.IssueOpened"
+    trigger Finding::RecordIssue, with: { issue_number: :issue_number }
+  end
+
+  policy "RecordTheSyncFailure" do
+    on      "Finding.GitHubRefused"
+    trigger Finding::RecordSyncFailure, with: { sync_failure: :refusal }
+  end
+end

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

@@ -0,0 +1,11 @@
+# The Tickets domain, bound so it boots standing alone (a fuzz or model_check boot of this
+# directory). The GitHubIssues port every attaching hecksagon shares is in tickets.ports.hecksagon.
+Hecks.hecksagon "Tickets" do
+  attaches "Governance"
+  persisted_by "Memory"
+end
+
+# The anti-corruption layer for Governance, which the chapter's roles are checked against.
+Hecks.hecksagon "Governance" do
+  persisted_by "Memory"
+end

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

@@ -0,0 +1,26 @@
+# The port Tickets declares, for every hecksagon that attaches the chapter (`Chapters` 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
+# finding and never blocks it. The port has to be declared even where no adapter binds it, so the
+# policies have a target and model_check's deaf-policy check can see it.
+#
+# Only OpenIssue answers with the issue number, so only its answer is recorded on the finding; the
+# other asks answer with a line saying what was done.
+Hecks.hecksagon "Tickets" do
+  Tickets::Finding.port "GitHubIssues" do
+    asks "OpenIssue", to: Finding do
+      attribute :finding, FindingKey
+      answers "IssueOpened"
+      refuses "GitHubRefused"
+    end
+
+    %w[LabelIssue CommentOnIssue CloseIssue ReopenIssue].each do |ask|
+      asks ask, to: Finding do
+        attribute :finding, FindingKey
+        answers "GitHubAnswered"
+        refuses "GitHubRefused"
+      end
+    end
+  end
+end

data/lib/hecks/tools/ci_gates.rb

@@ -102,7 +102,7 @@ module Hecks
           "      - uses: ./.github/actions/hecks-environment",
           "      - id: diff",
           "        name: #{quoted(gate.fetch('label'))}",
-          "        run: bundle exec exe/hecks decide_ci_gate gate=#{name} --wait",
+          "        run: bundle exec exe/hecks regeneration_run.decide_ci_gate gate=#{name} --wait",
           "  # END GENERATED ci_gate #{name}"
         ].join("\n")
       end

data/lib/hecks/tools/deploy_recipe.rb

@@ -11,7 +11,7 @@ module Hecks
     # target and dispatches to the matching `Projector` export, writing the recipe (template,
     # scripts and Makefile) under `deploy/<stack>/` of the checkout.
     #
-    #   hecks deploy project <domain> [--tenant=<slug>] [--schema=<name>]
+    #   hecks deploy recipe.project <domain> [--tenant=<slug>] [--schema=<name>]
     #       [--out=<dir>] [--environment=<name>]
     #
     # `--environment` layers an overlay `.world` file over the base one; a missing overlay is an
@@ -96,7 +96,7 @@ module Hecks
 
         File.exist?(world_file) or
           abort "#{world_file} does not exist — a domain needs a .world file to declare " \
-                "deployed_to(\"AwsLambda\") or deployed_to(\"AwsFargate\")"
+                "deployed_to(\"AwsLambda\"), deployed_to(\"AwsFargate\") or deployed_to(\"AwsBox\")"
         world_file
       end
 
@@ -150,7 +150,7 @@ module Hecks
       # Loads the whole registry a domain boots with, not just its own `.bluebook`, because a
       # cross-domain invoke grant can live in any attached chapter. A domain with no bluebook of
       # its own (the QA ledger) gets its chapter from the hecksagon's `Chapters.load!`. `root:` is
-      # required or `uses_embryonaut_bluebook` refuses with "needs a registry with a root to
+      # required or `attaches ... from: :vendor` refuses with "needs a registry with a root to
       # vendor from".
       #
       # @param domain [String] the domain directory
@@ -176,15 +176,16 @@ module Hecks
       # @param deploy_settings [Hash] the world's `deployed_to` settings
       # @param world_file [String] the `.world` file, named in the refusal
       # @param domain [String] the domain directory, named in the refusal
-      # @return [Symbol] `:aws_lambda` or `:aws_fargate`
-      # @raise [SystemExit] with an example block when the world declares neither
+      # @return [Symbol] `:aws_lambda`, `:aws_fargate` or `:aws_box`
+      # @raise [SystemExit] with an example block when the world declares none of them
       def target_key(deploy_settings, world_file, domain)
         case deploy_settings[:adapter]
         when "AwsLambda" then :aws_lambda
         when "AwsFargate" then :aws_fargate
+        when "AwsBox" then :aws_box
         else
           abort <<~MSG
-            #{world_file} declares no deployed_to("AwsLambda") or deployed_to("AwsFargate") block. Add one, e.g.:
+            #{world_file} declares no deployed_to("AwsLambda"), deployed_to("AwsFargate") or deployed_to("AwsBox") block. Add one, e.g.:
 
                 deployed_to("AwsLambda") do
                   region "us-east-1"
@@ -201,6 +202,13 @@ module Hecks
                   port 8080
                 end
 
+            or:
+
+                deployed_to("AwsBox") do
+                  region "us-east-1"
+                  containers [{ name: "web", port: 8080 }]
+                end
+
             then re-run hecks deploy project #{domain}.
           MSG
         end