chrono_forge 0.10.0 → 0.11.0

data/lib/chrono_forge/executor/methods/durably_repeat.rb

@@ -107,20 +107,28 @@ module ChronoForge
           validate_step_name_segment!(name || method)
           step_name = "durably_repeat$#{name || method}"
 
-          # Get or create the main coordination log for this periodic task
+          # Get or create the main coordination log for this periodic task. A fresh
+          # coordinator records its first pass in the INSERT (attempts: 1,
+          # last_executed_at); only later passes bump via UPDATE.
           coordination_log = find_or_create_execution_log!(step_name) do |log|
-            log.started_at = Time.current
+            now = Time.current
+            log.started_at = now
+            log.last_executed_at = now
+            log.attempts = 1
             log.metadata = {last_execution_at: nil}
           end
 
           # Return if already completed
           return if coordination_log.completed?
 
-          # Update coordination log attempt tracking
-          coordination_log.update!(
-            attempts: coordination_log.attempts + 1,
-            last_executed_at: Time.current
-          )
+          # Update coordination log attempt tracking (first pass already recorded
+          # above on create).
+          unless coordination_log.previously_new_record?
+            coordination_log.update!(
+              attempts: coordination_log.attempts + 1,
+              last_executed_at: Time.current
+            )
+          end
 
           # Check if we should stop repeating
           condition_met = if till.is_a?(Symbol)
@@ -252,9 +260,14 @@ module ChronoForge
         def execute_or_schedule_repetition(method, coordination_log, next_execution_at, every, policy, timeout, on_error)
           step_name = "#{coordination_log.step_name}$#{next_execution_at.to_i}"
 
-          # Create execution log for this specific repetition
+          # Create execution log for this specific repetition. A fresh repetition
+          # records its first attempt in the INSERT itself (attempts: 1,
+          # last_executed_at), so there is no separate pre-execution UPDATE.
           repetition_log = find_or_create_execution_log!(step_name) do |log|
-            log.started_at = Time.current
+            now = Time.current
+            log.started_at = now
+            log.last_executed_at = now
+            log.attempts = 1
             log.metadata = {
               scheduled_for: next_execution_at,
               timeout_at: next_execution_at + timeout,
@@ -265,11 +278,14 @@ module ChronoForge
           # Return if this repetition is already completed
           return if repetition_log.completed?
 
-          # Update execution log with attempt
-          repetition_log.update!(
-            attempts: repetition_log.attempts + 1,
-            last_executed_at: Time.current
-          )
+          # Existing logs (a resume of a scheduled-for-later repetition) still need
+          # the attempt bump; a freshly-created one recorded its first above.
+          unless repetition_log.previously_new_record?
+            repetition_log.update!(
+              attempts: repetition_log.attempts + 1,
+              last_executed_at: Time.current
+            )
+          end
 
           # Check if it's time to execute this repetition
           if next_execution_at <= Time.current

data/lib/chrono_forge/executor/methods/merge_branches.rb

@@ -5,7 +5,8 @@ module ChronoForge
         # Join one or more named branches. Separate from dispatch so branches run
         # concurrently. Does one immediate check; if not done, hands off to the
         # lightweight BranchMergeJob and halts (the heavy parent is not replayed
-        # per poll). Cadence clamps between min/max, scaled by pending.
+        # per poll). Poll cadence is driven by estimated time-to-drain, clamped
+        # between min/max (see BranchMergeJob#reschedule_delay).
         def merge_branches(*names, min_interval: 5.seconds, max_interval: 5.minutes)
           names.each do |nm|
             validate_step_name_segment!(nm)  # rejects "$"
@@ -16,9 +17,9 @@ module ChronoForge
           end
 
           # Validate cadence here, in the parent, so a misconfiguration fails at the
-          # call site instead of deep inside the poller — where (pending * FACTOR)
-          # .clamp(min, max) would raise ArgumentError, a non-transient error that
-          # dead-letters BranchMergeJob and orphans the parent.
+          # call site instead of deep inside the poller — where the clamp to
+          # [min_interval, max_interval] would raise ArgumentError, a non-transient
+          # error that dead-letters BranchMergeJob and orphans the parent.
           if min_interval > max_interval
             raise ArgumentError,
               "min_interval (#{min_interval}) must be <= max_interval (#{max_interval})"

data/lib/chrono_forge/executor/methods/workflow_states.rb

@@ -50,34 +50,28 @@ module ChronoForge
         def complete_workflow!
           enforce_branch_joins!
 
-          # Create an execution log for workflow completion
-          execution_log = find_or_create_execution_log!("$workflow_completion$") do |log|
-            log.started_at = Time.current
-          end
-
+          # Completion is two writes with no external side effect between them: the
+          # workflow → :completed transition and the (born-completed) marker. Batch
+          # them in one transaction so a trivial child pays a single commit here,
+          # and write the marker in its terminal state in a single INSERT.
+          execution_log = nil
           begin
-            workflow.completed_at = Time.current
-            workflow.completed!
-
-            # Mark execution log as completed. Attempt tracking and the terminal
-            # state are written together: completion is not retried on an
-            # attempt-count basis, so there is no need for a separate pre-write.
-            execution_log.update!(
-              attempts: execution_log.attempts + 1,
-              last_executed_at: Time.current,
-              state: :completed,
-              completed_at: Time.current
-            )
+            ActiveRecord::Base.transaction do
+              workflow.completed_at = Time.current
+              workflow.completed!
+              execution_log = create_completed_execution_log!("$workflow_completion$")
+            end
 
             # Return the execution log for tracking
             execution_log
           rescue => e
-            # Log any errors
-            execution_log.update!(
-              state: :failed,
-              error_message: e.message,
-              error_class: e.class.name
-            )
+            # The transaction rolled back (so the marker may be gone too). Re-find
+            # or recreate it and record the failure for observability, then re-raise.
+            # The workflow stays not-completed, so a resume retries completion.
+            log = find_or_create_execution_log!("$workflow_completion$") do |l|
+              l.started_at = Time.current
+            end
+            log.update!(state: :failed, error_message: e.message, error_class: e.class.name)
             raise
           end
         end
@@ -153,36 +147,30 @@ module ChronoForge
         # - Safe to call multiple times with same error_log
         #
         def fail_workflow!(error_log)
-          # Create an execution log for workflow failure
-          execution_log = find_or_create_execution_log!("$workflow_failure$#{error_log.id}") do |log|
-            log.started_at = Time.current
-            log.metadata = {
-              error_log_id: error_log.id
-            }
-          end
+          step_name = "$workflow_failure$#{error_log.id}"
 
+          # Mirror complete_workflow!: the workflow → :failed transition and the
+          # (born-completed) failure marker are batched in one transaction, and the
+          # marker is written in its terminal state in a single INSERT.
+          execution_log = nil
           begin
-            workflow.failed!
-
-            # Mark execution log as completed. Attempt tracking and the terminal
-            # state are written together (failure handling is not retried on an
-            # attempt-count basis).
-            execution_log.update!(
-              attempts: execution_log.attempts + 1,
-              last_executed_at: Time.current,
-              state: :completed,
-              completed_at: Time.current
-            )
+            ActiveRecord::Base.transaction do
+              workflow.failed!
+              execution_log = create_completed_execution_log!(step_name) do |log|
+                log.metadata = {error_log_id: error_log.id}
+              end
+            end
 
             # Return the execution log for tracking
             execution_log
           rescue => e
-            # Log any errors
-            execution_log.update!(
-              state: :failed,
-              error_message: e.message,
-              error_class: e.class.name
-            )
+            # The transaction rolled back; re-find/recreate the marker and record
+            # the failure for observability, then re-raise.
+            log = find_or_create_execution_log!(step_name) do |l|
+              l.started_at = Time.current
+              l.metadata = {error_log_id: error_log.id}
+            end
+            log.update!(state: :failed, error_message: e.message, error_class: e.class.name)
             raise
           end
         end

data/lib/chrono_forge/executor.rb

@@ -210,15 +210,6 @@ module ChronoForge
           workflow.kwargs = kwargs
           workflow.started_at = Time.current
         end
-
-      # Branch children are pre-inserted by their parent (dispatch_children's
-      # insert_all), so the creation block above never runs for them and their
-      # started_at stays nil. Stamp it the first time the child actually executes
-      # so started_at reliably means "has been picked up and run" — the
-      # BranchMergeJob rekick poller treats a nil started_at as a never-executed
-      # (dropped) child, and must not mistake a child that ran and is now parked
-      # on a wait (also :idle) for one that was never picked up.
-      @workflow.update_column(:started_at, Time.current) if @workflow.started_at.nil?
     end
 
     def setup_context!
@@ -259,6 +250,40 @@ module ChronoForge
         ExecutionLog.create_or_find_by!(workflow: @workflow, step_name: step_name, &)
     end
 
+    # Record a step that completes synchronously within this pass as a single
+    # INSERT already in its terminal :completed state — there is no
+    # started→completed UPDATE chasing the INSERT (one statement, not two). Use
+    # this for steps with no deferral point between create and completion
+    # (workflow completion/failure markers and similar); deferring steps (waits,
+    # branch coordination) must stay :started across resumes and use
+    # find_or_create_execution_log! instead.
+    #
+    # Idempotent: an already-existing row (a resume after a partial pass, or a
+    # create race) is flipped to :completed instead of duplicated. The block runs
+    # only on create, letting callers attach metadata to the new row.
+    def create_completed_execution_log!(step_name)
+      now = Time.current
+      log = find_or_create_execution_log!(step_name) do |l|
+        l.attempts = 1
+        l.started_at = now
+        l.last_executed_at = now
+        l.completed_at = now
+        l.state = :completed
+        yield l if block_given?
+      end
+
+      unless log.completed?
+        log.update!(
+          attempts: log.attempts + 1,
+          last_executed_at: now,
+          completed_at: now,
+          state: :completed
+        )
+      end
+
+      log
+    end
+
     # One bulk read of this workflow's completed steps, mapping step_name to its
     # metadata, memoized for the duration of a single replay pass.
     #

data/lib/chrono_forge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChronoForge
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/chrono_forge.rb

@@ -13,4 +13,12 @@ module ChronoForge
   class Error < StandardError; end
 
   def self.ApplicationRecord = defined?(::ApplicationRecord) ? ::ApplicationRecord : ActiveRecord::Base
+
+  # Engine configuration (see ChronoForge::Configuration).
+  #   ChronoForge.configure { |c| c.branch_merge_queue = :chrono_forge_pollers }
+  def self.config = @config ||= Configuration.new
+
+  def self.configure = yield(config)
+
+  def self.reset_configuration! = @config = Configuration.new
 end

data/lib/tasks/release.rake

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+# Release flow (chrono_forge monorepo: core + dashboard)
+# ------------------------------------------------------
+# Publishing happens from a laptop. CI does NOT push to any registry — it only
+# cuts the GitHub Release (notes + the built gem) when the tag lands.
+#
+#   1. rake release:core:prepare           # auto-computes next version (git-cliff)
+#      rake release:core:prepare[0.11.0]   # ...or pass one explicitly
+#   2. git diff                            # review the bump + changelog (nothing committed yet)
+#   3. rake release:core:publish           # commit, build + push gem, then tag + push → CI cuts the Release
+#
+# Same tasks under release:dashboard:*. Release `core` BEFORE `dashboard` —
+# the dashboard depends on core, so bump its `chrono_forge` floor first if needed.
+#
+# prepare leaves the bump + changelog UNCOMMITTED so you can review the diff
+# first; publish commits them, then publishes. publish is idempotent + resumable:
+# it skips a gem already live and only tags if the tag is missing, so a partial
+# failure can just be re-run.
+
+RELEASE_CLIFF_CONFIG = "cliff.toml"
+
+# Per-gem config. tag_pattern + scope mirror what each CHANGELOG should reflect:
+# core = everything except the dashboard subtree, dashboard = only that subtree.
+RELEASE_GEMS = {
+  "core" => {
+    name: "chrono_forge",
+    version_file: "lib/chrono_forge/version.rb",
+    changelog: "CHANGELOG.md",
+    gemspec: "chrono_forge.gemspec",
+    build_dir: ".",
+    tag_prefix: "v",
+    tag_pattern: "^v[0-9]",
+    scope: ["--exclude-path", "chrono_forge-dashboard/**"],
+    extra_files: []
+  },
+  "dashboard" => {
+    name: "chrono_forge-dashboard",
+    version_file: "chrono_forge-dashboard/lib/chrono_forge/dashboard/version.rb",
+    changelog: "chrono_forge-dashboard/CHANGELOG.md",
+    gemspec: "chrono_forge-dashboard.gemspec",
+    build_dir: "chrono_forge-dashboard",
+    tag_prefix: "chrono_forge-dashboard-v",
+    tag_pattern: "^chrono_forge-dashboard-v[0-9]",
+    scope: ["--include-path", "chrono_forge-dashboard/**"],
+    # The dashboard ships a compiled stylesheet — recompile it so the tagged
+    # tree (and the gem) never ship CSS that lags the source/views.
+    assets: -> {
+      Dir.chdir("chrono_forge-dashboard") do
+        system("bundle", "exec", "rake", "tailwind:build") || abort("tailwind:build failed")
+      end
+    },
+    extra_files: ["chrono_forge-dashboard/app/assets/chrono_forge/dashboard/dashboard.css"]
+  }
+}
+
+namespace :release do
+  # --- helpers --------------------------------------------------------------
+
+  def git_cliff?
+    system("which git-cliff > /dev/null 2>&1")
+  end
+
+  def release_current_version(cfg)
+    File.read(cfg[:version_file])[/VERSION = "([\d.]+)"/, 1] ||
+      abort("Could not read VERSION from #{cfg[:version_file]}")
+  end
+
+  def release_cliff_cmd(cfg, *extra)
+    ["git-cliff", "--config", RELEASE_CLIFF_CONFIG, "--tag-pattern", cfg[:tag_pattern], *cfg[:scope], *extra]
+  end
+
+  # Capture git-cliff stdout, discarding the stderr update-check chatter.
+  def release_capture(cmd)
+    IO.popen(cmd, err: File::NULL, &:read)
+  end
+
+  # Next version per conventional commits. git-cliff owns the semver math
+  # (including the pre-1.0 rules under [bump] in cliff.toml). Returns it
+  # without the gem's tag prefix.
+  def release_next_version(cfg)
+    abort "git-cliff not found. Install with: brew install git-cliff" unless git_cliff?
+    bumped = release_capture(release_cliff_cmd(cfg, "--bumped-version")).strip
+    abort "git-cliff could not compute a version (no conventional commits since the last #{cfg[:name]} tag?)" if bumped.empty?
+    bumped.delete_prefix(cfg[:tag_prefix])
+  end
+
+  def release_gem_published?(cfg, version)
+    out = `gem list --remote --exact --all #{cfg[:name]} 2>/dev/null`
+    out.include?("#{version},") || out.include?("#{version})") || out.include?(" #{version} ")
+  end
+
+  # Inject ONLY this version's section above the latest entry. A full -o regen
+  # would misattribute past releases because path-filtering confuses cliff's
+  # historical tag boundaries; existing entries are preserved verbatim.
+  def release_prepend_changelog(path, section)
+    body = File.read(path)
+    block = "#{section.strip}\n\n"
+    updated = (body =~ /^## \[/) ? body.sub(/^## \[/, "#{block}## [") : "#{body.rstrip}\n\n#{block}"
+    File.write(path, updated)
+  end
+
+  # --- per-gem tasks --------------------------------------------------------
+
+  RELEASE_GEMS.each do |key, cfg|
+    namespace key do
+      desc "Show #{cfg[:name]}'s next version computed from conventional commits"
+      task :version do
+        puts "#{cfg[:name]} current: #{release_current_version(cfg)}"
+        puts "#{cfg[:name]} next:    #{release_next_version(cfg)}"
+      end
+
+      desc "Prepare a #{cfg[:name]} release commit (bump + changelog + assets). Version optional; git-cliff computes it."
+      task :prepare, [:version] do |_t, args|
+        version = args[:version] || release_next_version(cfg)
+        abort "Error: version must be in format X.Y.Z (got #{version.inspect})" unless version.match?(/^\d+\.\d+\.\d+$/)
+        abort "Error: working tree is dirty. Commit or stash first." unless `git status --porcelain`.strip.empty?
+        abort "Error: not on main." unless `git rev-parse --abbrev-ref HEAD`.strip == "main"
+
+        system("git fetch -q origin")
+        abort "Error: main is not in sync with origin/main." unless `git rev-parse HEAD`.strip == `git rev-parse origin/main`.strip
+
+        tag = "#{cfg[:tag_prefix]}#{version}"
+        abort "Error: tag #{tag} already exists." if system("git rev-parse #{tag} >/dev/null 2>&1")
+
+        puts "Preparing #{cfg[:name]} #{version} (tag #{tag})..."
+
+        # Bump version.
+        content = File.read(cfg[:version_file])
+        File.write(cfg[:version_file], content.gsub(/VERSION = "[\d.]+"/, %(VERSION = "#{version}")))
+        puts "✓ #{cfg[:version_file]}"
+
+        # Compile assets (dashboard CSS), if any.
+        cfg[:assets]&.call
+
+        # Changelog — same config CI uses for the notes, so they agree.
+        section = release_capture(release_cliff_cmd(cfg, "--tag", tag, "--unreleased", "--strip", "all"))
+        abort "git-cliff found no entries since the last #{cfg[:name]} tag — nothing to release." if section.strip.empty?
+        release_prepend_changelog(cfg[:changelog], section)
+        puts "✓ #{cfg[:changelog]}"
+
+        # Leave everything uncommitted so the bump + changelog can be reviewed
+        # before anything is committed or published. publish makes the commit.
+        files = [cfg[:version_file], cfg[:changelog], *cfg[:extra_files]]
+
+        puts "\n✓ Prepared #{cfg[:name]} #{version} — nothing committed yet."
+        puts "Next:"
+        puts "  git diff -- #{files.join(" ")}"
+        puts "  rake release:#{key}:publish   # commit, build + push gem, then tag + push"
+        puts "  (abort with: git checkout -- #{files.join(" ")})"
+      end
+
+      desc "Publish #{cfg[:name]} (build + push gem, then tag + push). Idempotent + resumable."
+      task :publish do
+        version = release_current_version(cfg)
+        tag = "#{cfg[:tag_prefix]}#{version}"
+        files = [cfg[:version_file], cfg[:changelog], *cfg[:extra_files]]
+
+        # Commit the prepared changes (you review the diff between prepare and
+        # here). Resumable: if they're already committed — e.g. a re-run after a
+        # partial failure — skip straight to publishing.
+        if `git status --porcelain -- #{files.join(" ")}`.strip.empty?
+          unless `git log -1 --format=%s`.strip == "chore(release): #{cfg[:name]} #{version}"
+            abort "Nothing prepared — run rake release:#{key}:prepare first."
+          end
+        else
+          system("git", "add", *files) || abort("git add failed")
+          system("git", "commit", "-m", "chore(release): #{cfg[:name]} #{version}") || abort("git commit failed")
+          puts "✓ Committed #{cfg[:name]} #{version}"
+        end
+
+        if release_gem_published?(cfg, version)
+          puts "• #{cfg[:name]} #{version} already on RubyGems — skipping"
+        else
+          puts "Building + pushing gem..."
+          Dir.chdir(cfg[:build_dir]) do
+            system("gem build #{cfg[:gemspec]}") || abort("Gem build failed")
+            gem_file = "#{cfg[:name]}-#{version}.gem"
+            system("gem push #{gem_file}") || abort("Gem push failed")
+            File.delete(gem_file) if File.exist?(gem_file)
+          end
+          puts "✓ Published #{cfg[:name]} #{version} to RubyGems"
+        end
+
+        # Tag + push last, so CI cuts the Release only once the gem is live.
+        branch = `git branch --show-current`.strip
+        if system("git rev-parse #{tag} >/dev/null 2>&1")
+          puts "• tag #{tag} already exists — skipping tag"
+        else
+          system("git", "tag", tag) || abort("git tag failed")
+        end
+        system("git", "push", "origin", branch) || abort("git push branch failed")
+        system("git", "push", "origin", tag) || abort("git push tag failed")
+
+        puts "\n✓ Released #{tag}. GitHub Actions will cut the Release from the tag."
+        if key == "core"
+          puts "  Next: bump the dashboard's chrono_forge floor if it should require #{version}, then release:dashboard:*"
+        end
+      end
+    end
+  end
+end
+
+# Neutralize the dangerous bare `rake release` that bundler/gem_tasks defines
+# (it would tag + gem push directly). Point people at the real flow instead.
+if Rake::Task.task_defined?("release")
+  Rake::Task["release"].clear
+  desc "Disabled — use release:core:* or release:dashboard:* (see lib/tasks/release.rake)"
+  task :release do
+    warn "Use `rake release:core:prepare` then `rake release:core:publish` (or :dashboard). See lib/tasks/release.rake."
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chrono_forge
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Stefan Froelich
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-27 00:00:00.000000000 Z
+date: 2026-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -194,7 +208,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- cliff.toml
 - config.ru
+- docs/design/per-child-commit-overhead.md
+- docs/fanout-scale-test.md
 - docs/superpowers/plans/2026-06-25-chrono_forge-dashboard.md
 - docs/superpowers/plans/2026-06-25-chrono_forge-dashboard.md.tasks.json
 - docs/superpowers/plans/2026-06-25-composite-retry-policies.md
@@ -205,6 +222,10 @@ files:
 - docs/superpowers/plans/2026-06-26-branches-spawn-merge.md.tasks.json
 - docs/superpowers/plans/2026-06-26-deferral-continuation-race-and-catchup.md
 - docs/superpowers/plans/2026-06-26-deferral-continuation-race-and-catchup.md.tasks.json
+- docs/superpowers/plans/2026-06-30-poller-rekick-and-eta-cadence.md
+- docs/superpowers/plans/2026-06-30-poller-rekick-and-eta-cadence.md.tasks.json
+- docs/superpowers/plans/2026-07-01-workflow-definition-dag.md
+- docs/superpowers/plans/2026-07-01-workflow-definition-dag.md.tasks.json
 - docs/superpowers/specs/2026-06-03-unified-retry-policy-design.md
 - docs/superpowers/specs/2026-06-25-chrono_forge-dashboard-design.md
 - docs/superpowers/specs/2026-06-25-composite-retry-policies-design.md
@@ -212,6 +233,7 @@ files:
 - docs/superpowers/specs/2026-06-25-spawn-merge-branches-design.md
 - docs/superpowers/specs/2026-06-26-dashboard-branch-view-design.md
 - docs/superpowers/specs/2026-06-26-deferral-continuation-race-and-catchup-design.md
+- docs/superpowers/specs/2026-07-01-workflow-definition-dag-design.md
 - examples/continue_if_webhook_example.rb
 - gemfiles/rails_7.1.gemfile
 - gemfiles/rails_7.1.gemfile.lock
@@ -220,6 +242,9 @@ files:
 - lib/chrono_forge/branch_probe.rb
 - lib/chrono_forge/cleanup.rb
 - lib/chrono_forge/cleanup_job.rb
+- lib/chrono_forge/configuration.rb
+- lib/chrono_forge/definition.rb
+- lib/chrono_forge/definition_analyzer.rb
 - lib/chrono_forge/error_log.rb
 - lib/chrono_forge/execution_log.rb
 - lib/chrono_forge/executor.rb
@@ -248,6 +273,7 @@ files:
 - lib/generators/chrono_forge/templates/install_chrono_forge.rb
 - lib/generators/chrono_forge/upgrade/USAGE
 - lib/generators/chrono_forge/upgrade/upgrade_generator.rb
+- lib/tasks/release.rake
 - sig/chrono_forge.rbs
 homepage: https://github.com/radioactive-labs/chrono_forge
 licenses: