command_tower 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b932782bd089979dc908cc1865cdeefe8839fba2a4e5dbdb4956e00484345450
-  data.tar.gz: c88d647eaa666f9593416acb3771e407f22d2ef090c7035f45b65b4cc2ff9265
+  metadata.gz: 8bf05b7d610367efda3b4dce6349bfbd002891563a5f16a5688bbd2660717896
+  data.tar.gz: 5a31b97e28d791fbda2ad4899c121fe54c2f96e944c387c716d5541d7449c8f6
 SHA512:
-  metadata.gz: b3cff84a5ecf68c9929e4c9eca099c2f551a97a886e8c2882b6d4e411d064cb9df24fb64e626b35e08d53b72bcca68950c5e7cd4c197c482415f040e76f89be4
-  data.tar.gz: aaa5bf71dadf4a4a8de13bcc25dd9c826a68c20c37cc014b86130b86d8ad7733d6a575608057a1f19c1d4e2435b79c5a2f679d7f8bb7d73c411886c9dfdfd712
+  metadata.gz: 6c1a8b5cf203cb35b4697f593324b94eb1a0e0a7c4d4b171c752b669a700862679a28cbbe494b54a632294181fa6ddf7d78aa117cf5a71e1deb7e9fc036b122e
+  data.tar.gz: 5232cb631564969ef269b82fd1b9c38ef820ee76523640a09b2846b380348b64e5c4dc62288b0a391edde0586b4e3d28559d26614788d26e7ba26ab8a96c7bd0

data/app/models/command_tower/messaging/delivery_attempt.rb

@@ -21,6 +21,11 @@ module CommandTower
                  class_name: "CommandTower::Messaging::ChannelDelivery",
                  inverse_of: :delivery_attempts
 
+      # MariaDB reports JSON columns as LONGTEXT. The text caster would write
+      # a Ruby hash string and fail `json_valid`. Forcing the JSON caster
+      # writes one JSON document on MySQL and on MariaDB.
+      attribute :provider_metadata, :json
+
       validates :status, presence: true, inclusion: { in: STATUSES }
       validates :started_at, presence: true
     end

data/app/services/command_tower/messaging/delivery_retry_policy.rb

@@ -8,6 +8,10 @@ module CommandTower
       MAX_ATTEMPTS = 5
       GRACE_WINDOW = 1.minute
 
+      PUSH_RETRY_LIMIT = 2
+      SUBMISSION_NOT_SUBMITTED = "not_submitted"
+      SUBMISSION_UNCERTAIN = "submission_uncertain"
+
       class << self
         def retries_exhausted?(delivery)
           delivery.status == ChannelDelivery::STATUS_FAILED_RETRYABLE &&
@@ -24,6 +28,99 @@ module CommandTower
 
           delivery.updated_at + GRACE_WINDOW
         end
+
+        def push_channel?(delivery)
+          delivery.channel_key == "push"
+        end
+
+        def max_execution_attempts_for(delivery)
+          push_channel?(delivery) ? PUSH_RETRY_LIMIT : MAX_ATTEMPTS
+        end
+
+        def confirmed_not_submitted?(attempt)
+          attempt.provider_metadata.is_a?(Hash) &&
+            attempt.provider_metadata["submission"] == SUBMISSION_NOT_SUBMITTED
+        end
+
+        def accepted_ticket_in_attempt?(attempt)
+          return true if attempt.status == Messaging::DeliveryAttempt::STATUS_SUCCEEDED
+
+          metadata = attempt.provider_metadata
+          return false unless metadata.is_a?(Hash)
+
+          endpoints = metadata.dig("expo", "endpoints")
+          return false unless endpoints.is_a?(Array)
+
+          endpoints.any? { |entry| entry["ticket_status"] == "ok" }
+        end
+
+        def push_has_open_started_attempt?(delivery)
+          delivery.delivery_attempts
+            .where(status: Messaging::DeliveryAttempt::STATUS_STARTED, finished_at: nil)
+            .exists?
+        end
+
+        def latest_finished_attempt(delivery)
+          delivery.delivery_attempts
+            .where.not(finished_at: nil)
+            .order(id: :desc)
+            .first
+        end
+
+        # Persisted proof only — not tied to channel delivery status.
+        def push_has_not_submitted_evidence?(delivery)
+          attempt = latest_finished_attempt(delivery)
+          attempt.present? && confirmed_not_submitted?(attempt)
+        end
+
+        def push_retry_budget_remaining?(delivery)
+          delivery.execution_attempt_count < PUSH_RETRY_LIMIT
+        end
+
+        # recover_failed! — delivery is failed_retryable.
+        def push_redrive_eligible_from_failed_retryable?(delivery)
+          return false unless push_channel?(delivery)
+          return false unless delivery.status == ChannelDelivery::STATUS_FAILED_RETRYABLE
+          return false if push_has_open_started_attempt?(delivery)
+          return false unless push_has_not_submitted_evidence?(delivery)
+
+          push_retry_budget_remaining?(delivery)
+        end
+
+        # recover_queued! / recover_stale_executing! — delivery may already be queued.
+        def push_redrive_eligible_while_queued?(delivery)
+          return true unless push_channel?(delivery)
+          return false if push_has_open_started_attempt?(delivery)
+          return true if delivery.delivery_attempts.none?
+
+          push_has_not_submitted_evidence?(delivery) && push_retry_budget_remaining?(delivery)
+        end
+
+        # DeliverWorkflow — may this execution call Expo?
+        def push_may_submit_to_provider?(delivery, current_attempt_id:)
+          return true unless push_channel?(delivery)
+
+          prior_attempts = delivery.delivery_attempts.where.not(id: current_attempt_id)
+          return false if prior_attempts
+            .where(status: Messaging::DeliveryAttempt::STATUS_STARTED, finished_at: nil)
+            .exists?
+
+          finished = prior_attempts.where.not(finished_at: nil)
+          return true if finished.none?
+
+          return false if finished.any? { |attempt| accepted_ticket_in_attempt?(attempt) }
+
+          return false if finished.any? do |attempt|
+            attempt.error_code == SUBMISSION_UNCERTAIN ||
+              (
+                attempt.status == Messaging::DeliveryAttempt::STATUS_FAILED_TERMINAL &&
+                  !confirmed_not_submitted?(attempt)
+              )
+          end
+
+          latest = finished.order(:id).last
+          confirmed_not_submitted?(latest) && delivery.execution_attempt_count <= PUSH_RETRY_LIMIT
+        end
       end
     end
   end

data/app/services/command_tower/messaging/execution/adapters/expo/adapter.rb

@@ -75,13 +75,10 @@ module CommandTower
               else
                 AdapterResult.build(outcome: :terminal_failure, error_code: "adapter_unconfigured")
               end
+            rescue HttpClient::RequestNotSubmitted
+              not_submitted_result(attempts, history:)
             rescue StandardError
-              # Keep the endpoint facts already recorded; the outcome stays today's rescue-all result.
-              AdapterResult.build(
-                outcome: :retryable_failure,
-                error_code: "expo_transient",
-                provider_metadata: provider_metadata_for(attempts),
-              )
+              uncertain_terminal_result(attempts, history:)
             end
 
             private
@@ -110,8 +107,8 @@ module CommandTower
               sendable = attempts.select { |attempt| attempt.token.present? && attempt.outcome.nil? }
               messages = sendable.map { |attempt| expo_message(token: attempt.token, rendered:, communication:) }
 
-              sendable.each { |attempt| attempt.submitted = true }
               send_result = @http_client.send_messages(messages)
+              sendable.each { |attempt| attempt.submitted = true }
               unless send_result[:ok]
                 return map_http_failure(send_result[:status_code], attempts:, history:)
               end
@@ -125,7 +122,7 @@ module CommandTower
 
               ok_ticket_ids = sendable.filter_map { |attempt| attempt.ticket&.dig(:id) if attempt.ticket&.dig(:status) == "ok" }
               if ok_ticket_ids.any?
-                receipts_result = @http_client.get_receipts(ok_ticket_ids)
+                receipts_result = fetch_receipts(ok_ticket_ids)
                 if receipts_result[:ok]
                   receipts = receipts_result[:receipts] || {}
                   sendable.each do |attempt|
@@ -148,6 +145,12 @@ module CommandTower
               aggregate_result(attempts, history:)
             end
 
+            def fetch_receipts(ticket_ids)
+              @http_client.get_receipts(ticket_ids)
+            rescue StandardError
+              { ok: false, status_code: nil, receipts: {} }
+            end
+
             # Every eligible endpoint already holds an accepted ticket or a recorded terminal
             # ticket error from an earlier attempt, so there is nothing to send.
             def settled_only_result(history)
@@ -194,8 +197,8 @@ module CommandTower
             def apply_ticket_outcome!(attempt)
               ticket = attempt.ticket
               if ticket.nil?
-                attempt.outcome = :retryable_failure
-                attempt.error_code = "expo_transient"
+                attempt.outcome = :terminal_failure
+                attempt.error_code = submission_uncertain_code
                 return
               end
 
@@ -211,8 +214,8 @@ module CommandTower
                   attempt.error_code = "expo_rejected"
                 end
               else
-                attempt.outcome = :retryable_failure
-                attempt.error_code = "expo_transient"
+                attempt.outcome = :terminal_failure
+                attempt.error_code = submission_uncertain_code
               end
             end
 
@@ -246,29 +249,49 @@ module CommandTower
               nil
             end
 
-            # 5xx and 429 stay retryable. Any other non-success response is terminal for this
-            # attempt even when an earlier attempt had accepted tickets; those tickets are carried
-            # into the metadata so the accepted facts stay visible on this row.
+            # After the HTTP client returns, a non-success response is uncertain for duplicate policy
+            # (request may have been accepted). Terminal rejection (4xx except 429) maps to expo_rejected.
             def map_http_failure(status_code, attempts:, history:)
-              retryable = status_code.to_i >= 500 || status_code.to_i == 429
-              outcome = retryable ? :retryable_failure : :terminal_failure
-              error_code = retryable ? "expo_transient" : "expo_rejected"
+              code = status_code.to_i
+              error_code =
+                if code >= 500 || code == 429
+                  submission_uncertain_code
+                else
+                  "expo_rejected"
+                end
               attempts.each { |attempt| attempt.error_code ||= error_code if attempt.submitted }
-              carried = retryable ? [] : carried_accepted_entries(history)
+              carried = error_code == submission_uncertain_code ? [] : carried_accepted_entries(history)
 
-              AdapterResult.build(outcome:, error_code:, provider_metadata: provider_metadata_for(attempts, carried:))
+              AdapterResult.build(
+                outcome: :terminal_failure,
+                error_code:,
+                provider_metadata: provider_metadata_for(attempts, carried:),
+              )
             end
 
             # Delivery-wide aggregation: this attempt's endpoints plus tickets recorded earlier.
             def aggregate_result(attempts, history:)
+              submitted = attempts.select(&:submitted)
               successes = attempts.select { |attempt| attempt.outcome == :success }
               first_ticket_id = successes.filter_map { |attempt| attempt.ticket&.dig(:id) }.first
               metadata = provider_metadata_for(attempts)
 
+              if submitted.any? { |attempt| attempt.outcome == :success } &&
+                 submitted.any? do |attempt|
+                   attempt.outcome == :terminal_failure && attempt.error_code == submission_uncertain_code
+                 end
+                return AdapterResult.build(
+                  outcome: :terminal_failure,
+                  error_code: submission_uncertain_code,
+                  provider_message_id: first_ticket_id,
+                  provider_metadata: metadata,
+                )
+              end
+
               if attempts.any? { |attempt| attempt.outcome == :retryable_failure }
                 return AdapterResult.build(
-                  outcome: :retryable_failure,
-                  error_code: "expo_transient",
+                  outcome: :terminal_failure,
+                  error_code: submission_uncertain_code,
                   provider_message_id: first_ticket_id,
                   provider_metadata: metadata,
                 )
@@ -290,13 +313,38 @@ module CommandTower
                 return AdapterResult.build(outcome: :terminal_failure, error_code:, provider_metadata: metadata)
               end
 
+              AdapterResult.build(
+                outcome: :terminal_failure,
+                error_code: submission_uncertain_code,
+                provider_metadata: metadata,
+              )
+            end
+
+            def not_submitted_result(_attempts, history: nil)
               AdapterResult.build(
                 outcome: :retryable_failure,
-                error_code: "expo_transient",
+                error_code: "expo_not_submitted",
+                provider_metadata: {
+                  "submission" => Messaging::DeliveryRetryPolicy::SUBMISSION_NOT_SUBMITTED,
+                },
+              )
+            end
+
+            def uncertain_terminal_result(attempts, history:)
+              metadata = provider_metadata_for(attempts)
+              metadata = metadata.merge("submission" => submission_uncertain_code) if metadata.is_a?(Hash)
+
+              AdapterResult.build(
+                outcome: :terminal_failure,
+                error_code: submission_uncertain_code,
                 provider_metadata: metadata,
               )
             end
 
+            def submission_uncertain_code
+              Messaging::DeliveryRetryPolicy::SUBMISSION_UNCERTAIN
+            end
+
             def carried_accepted_entries(history)
               history.accepted_ticket_ids.map do |endpoint_id, ticket_id|
                 entry = { "endpoint_id" => endpoint_id, "ticket_status" => "ok" }

data/app/services/command_tower/messaging/execution/adapters/expo/http_client.rb

@@ -12,6 +12,8 @@ module CommandTower
           # Narrow Expo Push HTTP client for Messaging notification push.
           # Never logs tokens, Authorization headers, or raw bodies that may contain tokens.
           class HttpClient
+            RequestNotSubmitted = Class.new(StandardError)
+
             def initialize(configuration: nil)
               @configuration = configuration || Configuration.new
             end
@@ -65,6 +67,8 @@ module CommandTower
               ) do |http|
                 http.request(request)
               end
+            rescue Net::OpenTimeout, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError => error
+              raise RequestNotSubmitted, error.message
             end
 
             def parse_send_response(response)

data/app/services/command_tower/messaging/execution/attempt_ledger.rb

@@ -108,6 +108,31 @@ module CommandTower
           now = Time.current
           resolved_class = error_class || error&.class&.name || "UnknownError"
 
+          if Messaging::DeliveryRetryPolicy.push_channel?(delivery)
+            uncertain = Messaging::DeliveryRetryPolicy::SUBMISSION_UNCERTAIN
+            ActiveRecord::Base.transaction do
+              attempt.update!(
+                status: Messaging::DeliveryAttempt::STATUS_FAILED_TERMINAL,
+                finished_at: now,
+                error_code: uncertain,
+                error_class: resolved_class,
+                normalized_provider_status: nil,
+                provider_message_id: nil,
+              )
+              delivery.update!(status: Messaging::ChannelDelivery::STATUS_FAILED_TERMINAL)
+            end
+
+            delivery.reload
+            attempt.reload
+            OperationLogger.attempt_failed(channel_delivery: delivery, delivery_attempt: attempt)
+            OperationLogger.failed(
+              channel_delivery: delivery,
+              error_code: uncertain,
+              error_class: resolved_class,
+            )
+            return delivery
+          end
+
           ActiveRecord::Base.transaction do
             attempt.update!(
               status: Messaging::DeliveryAttempt::STATUS_FAILED_RETRYABLE,
@@ -128,8 +153,17 @@ module CommandTower
             error_code: "internal_adapter_error",
             error_class: resolved_class,
           )
-        rescue StandardError
-          mark_failed_retryable_best_effort!(delivery)
+        rescue StandardError => error
+          OperationLogger.attempt_finalize_unpersisted(
+            channel_delivery: delivery,
+            delivery_attempt: attempt,
+            error_class: error.class.name,
+          )
+          if Messaging::DeliveryRetryPolicy.push_channel?(delivery)
+            mark_failed_terminal_best_effort!(delivery)
+          else
+            mark_failed_retryable_best_effort!(delivery)
+          end
         end
 
         private
@@ -143,6 +177,12 @@ module CommandTower
         rescue StandardError
           nil
         end
+
+        def mark_failed_terminal_best_effort!(delivery)
+          delivery.update(status: Messaging::ChannelDelivery::STATUS_FAILED_TERMINAL)
+        rescue StandardError
+          nil
+        end
       end
     end
   end

data/app/services/command_tower/messaging/execution/operation_logger.rb

@@ -103,6 +103,16 @@ module CommandTower
             )
           end
 
+          def attempt_finalize_unpersisted(channel_delivery:, delivery_attempt:, error_class:)
+            emit(
+              :error,
+              "messaging.execution.attempt.finalize_unpersisted",
+              channel_delivery:,
+              delivery_attempt_id: delivery_attempt.id,
+              error_class:,
+            )
+          end
+
           def render_started(channel_delivery:, delivery_attempt:)
             emit_render(
               :info,

data/app/services/command_tower/messaging/execution/recovery.rb

@@ -43,30 +43,86 @@ module CommandTower
           Messaging::ChannelDelivery
             .queued_for_execution
             .where(Messaging::ChannelDelivery.arel_table[:updated_at].lt(grace_before))
-            .find_each { |delivery| redrive!(delivery) }
+            .find_each { |delivery| redrive_queued_delivery!(delivery) }
         end
 
         def recover_failed!
           Messaging::ChannelDelivery
             .failed_retryable
             .where(Messaging::ChannelDelivery.arel_table[:updated_at].lt(grace_before))
-            .where(Messaging::ChannelDelivery.arel_table[:execution_attempt_count].lt(@max_attempts))
-            .find_each do |delivery|
-              reset_to_queued!(delivery)
-              redrive!(delivery.reload)
-            end
+            .find_each { |delivery| redrive_failed_delivery!(delivery) }
         end
 
         def recover_stale_executing!
           Messaging::ChannelDelivery
             .executing
             .where(Messaging::ChannelDelivery.arel_table[:execution_claimed_at].lt(grace_before))
-            .find_each do |delivery|
-              next if delivery.execution_attempt_count >= @max_attempts
+            .find_each { |delivery| redrive_stale_executing_delivery!(delivery) }
+        end
+
+        def redrive_queued_delivery!(delivery)
+          if Messaging::DeliveryRetryPolicy.push_channel?(delivery)
+            if Messaging::DeliveryRetryPolicy.push_redrive_eligible_while_queued?(delivery)
+              redrive!(delivery)
+            else
+              terminalize_push_uncertain!(delivery)
+            end
+            return
+          end
+
+          redrive!(delivery)
+        end
+
+        def redrive_failed_delivery!(delivery)
+          if Messaging::DeliveryRetryPolicy.push_channel?(delivery)
+            if Messaging::DeliveryRetryPolicy.push_redrive_eligible_from_failed_retryable?(delivery)
+              reset_to_queued!(delivery)
+              redrive!(delivery.reload)
+            else
+              terminalize_push_uncertain!(delivery)
+            end
+            return
+          end
+
+          return if delivery.execution_attempt_count >= @max_attempts
+
+          reset_to_queued!(delivery)
+          redrive!(delivery.reload)
+        end
+
+        def redrive_stale_executing_delivery!(delivery)
+          max_attempts = Messaging::DeliveryRetryPolicy.max_execution_attempts_for(delivery)
+          return if delivery.execution_attempt_count >= max_attempts
 
+          if Messaging::DeliveryRetryPolicy.push_channel?(delivery)
+            if Messaging::DeliveryRetryPolicy.push_redrive_eligible_while_queued?(delivery)
               reset_to_queued!(delivery)
               redrive!(delivery.reload)
+            else
+              terminalize_push_uncertain!(delivery)
             end
+            return
+          end
+
+          reset_to_queued!(delivery)
+          redrive!(delivery.reload)
+        end
+
+        def terminalize_push_uncertain!(delivery)
+          now = Time.current
+          uncertain = Messaging::DeliveryRetryPolicy::SUBMISSION_UNCERTAIN
+
+          Messaging::DeliveryAttempt
+            .where(channel_delivery_id: delivery.id, status: Messaging::DeliveryAttempt::STATUS_STARTED, finished_at: nil)
+            .find_each do |attempt|
+              attempt.update!(
+                status: Messaging::DeliveryAttempt::STATUS_FAILED_TERMINAL,
+                finished_at: now,
+                error_code: uncertain,
+              )
+            end
+
+          delivery.update!(status: Messaging::ChannelDelivery::STATUS_FAILED_TERMINAL)
         end
 
         def reset_to_queued!(delivery)

data/app/workflows/command_tower/workflows/messaging/execution/deliver_workflow.rb

@@ -108,6 +108,25 @@ module CommandTower
                 )
               end
 
+              unless CommandTower::Messaging::DeliveryRetryPolicy.push_may_submit_to_provider?(
+                delivery,
+                current_attempt_id: attempt.id,
+              )
+                ledger.finalize_terminal(
+                  delivery:,
+                  attempt:,
+                  error_code: CommandTower::Messaging::DeliveryRetryPolicy::SUBMISSION_UNCERTAIN,
+                )
+                return success(
+                  payload: {
+                    outcome: :terminal,
+                    channel_delivery_id: delivery.id,
+                    error_code: CommandTower::Messaging::DeliveryRetryPolicy::SUBMISSION_UNCERTAIN,
+                  },
+                  http_status: :ok,
+                )
+              end
+
               request = CommandTower::Messaging::Execution::AdapterRequest.build(
                 channel_delivery_id: delivery.id,
                 communication_id: delivery.communication_id,

data/docs/upgrades/0.20.0.md

@@ -0,0 +1,29 @@
+# Upgrade: CommandTower 0.20.0
+
+**From:** `0.19.0`  
+**To:** `0.20.0`
+
+Minor release: push delivery certainty — persist Expo ticket metadata reliably on MariaDB and stop duplicate Expo sends when submission is uncertain. Email retry policy and Inbox behavior are unchanged.
+
+## Host-visible changes
+
+| Change | Host impact |
+|--------|-------------|
+| `DeliveryAttempt#provider_metadata` | JSON attribute caster (MariaDB LONGTEXT / `json_valid`). Accepted Expo ticket metadata persists on success and retryable non-submission paths. |
+| Push execution recovery | Push-only duplicate-averse policy: at most one automatic retry when a finished attempt recorded `submission: not_submitted`. Uncertain outcomes (`submission_uncertain`), accepted tickets, and open `started` attempts without proof terminalize without another Expo POST. Push claim budget `PUSH_RETRY_LIMIT` = 2. Email keeps grace window and `MAX_ATTEMPTS` = 5. |
+| `DeliverWorkflow` | Pre-send guard blocks Expo when prior push state does not allow another submission. |
+| Expo adapter | Classifies pre-request failures as `not_submitted` (retryable once); post-dispatch uncertainty is terminal. |
+| Observability | `messaging.execution.attempt.finalize_unpersisted` when attempt finalization cannot be persisted (diagnostic). |
+
+## Host actions
+
+1. Bump gem to `0.20.0` (or `>= 0.20.0`).
+2. **No new migration.** Run `bundle exec rails db:migrate` only if other pending host migrations exist.
+3. After deploy, legacy push rows with `started` attempts and null metadata are terminalized on the next recovery pass (no data repair script).
+
+## Not in this release
+
+- No Inbox document or rendering changes.
+- No email adapter or email retry cap changes.
+- No new HTTP routes or workflows.
+- No automatic backfill of historical `provider_metadata`.

data/docs/upgrades/README.md

@@ -4,6 +4,7 @@ Host-facing upgrade / change summaries for CommandTower releases.
 
 | Version | Summary |
 |---------|---------|
+| [0.20.0](0.20.0.md) | Push delivery certainty: JSON `provider_metadata` caster; duplicate-averse push recovery and Expo submission guards |
 | [0.19.0](0.19.0.md) | Push presentation: badge, urgency, sound, deep links; Expo ticket and receipt metadata; preference urgency and sound |
 | [0.18.0](0.18.0.md) | Inbox conversations: optional Produce identity, grouped list entries, `GET /me/inbox/conversation` window of at most 5, accept-time presentation snapshot |
 | [0.17.0](0.17.0.md) | Client-version-compatibility gating (`observe`/`enforce`); Rich Messaging Inbox `content` documents; host-overridable rendering templates; shared email theming |

data/lib/command_tower/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CommandTower
-  VERSION = "0.19.0"
+  VERSION = "0.20.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_tower
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - matt-taylor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phonelib
@@ -860,6 +860,7 @@ files:
 - docs/upgrades/0.17.0.md
 - docs/upgrades/0.18.0.md
 - docs/upgrades/0.19.0.md
+- docs/upgrades/0.20.0.md
 - docs/upgrades/README.md
 - lib/command_tower.rb
 - lib/command_tower/admin_scope.rb