prdigest 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 409ae44cab5ad005c5dcb413632295fdd3aae2e8d6383852b71863f8fc484d15
-  data.tar.gz: 7ae70339af9e94123d83795362bfde4c07ee57d94bf447123fe4ce305f9117b4
+  metadata.gz: 9ff60040fe7091056de1781ae7154e758145cf7216ec1b664adc661cd479c96f
+  data.tar.gz: aa87baccb18ac37b7398c83e5d312187e3d697fa8fa9e161c6f3b930cef73ae4
 SHA512:
-  metadata.gz: f5c7c0e265e13c87e2a625c3ee8fd10cde644b99297277b0dd5fd1f2f4a980ea0d7d81f67a63021b9741af8811b8903af47595c9713b507dd36fb749118e4489
-  data.tar.gz: 4c787a605900e7f93722a72929708cf5032e35d1aff08a2134d41430d6e17b58f578ef20d965141391c87943eefbe3e99781a99cfcf72f08e0b35257c90d1d50
+  metadata.gz: 2e7499399445ffa51a7acb8bd0f7066bf3f930108d56f070cafdfdc49e4a8b6727b6288b3a5e95cae3ed36f6e01c19fa90726522c6aeb731a45edf1c6a88718a
+  data.tar.gz: 7bc1c60e8518b9abebeb1beb6fdb08b12aafb39beb4056db7f96fc225b2344e9643f5d27108138a4eecb06d100db16f55c18dd075ffdc35152087b7f5ad58dc3

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.0 - 2026-07-27
+
+- Remove `prdigest run`, deterministic Telegram HTML, schedule/cursor state,
+  catch-up processing, the `prdigest-result` envelope, and the `serve` stub.
+- Keep `prdigest facts` for agents and `prdigest prose` for stdout or
+  checkpointed plain-text Telegram delivery.
+- Make `prdigest prose --deliver` the systemd and container default.
+
 ## 0.2.0 - 2026-07-26
 
 - Add a deterministic `prdigest facts` JSON contract over the canonical

data/README.md

@@ -2,7 +2,7 @@
 
 <h1>PRDigest</h1>
 
-<p><strong>One source of truth for merged pull requests. Three ways to present it.</strong></p>
+<p><strong>One merged-PR facts contract. Prose for people and JSON for agents.</strong></p>
 
 <p>
   <a href="https://github.com/ivankuznetsov/prdigest/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/ivankuznetsov/prdigest/actions/workflows/ci.yml/badge.svg"></a>
@@ -12,9 +12,8 @@
 </p>
 
 <p>
-  Collect merged PRs once, then deliver a deterministic Telegram digest, emit<br>
-  stable JSON for an agent, or generate optional prose through an
-  OpenAI-compatible Chat Completions endpoint.
+  Give OpenClaw and other agents stable merged-PR facts, or generate concise<br>
+  prose through any OpenAI-compatible Chat Completions endpoint.
 </p>
 
 <p>
@@ -38,17 +37,15 @@ changes what was fetched from GitHub.
 ```mermaid
 flowchart LR
     GH[GitHub repositories] --> C[Canonical collector]
-    C --> RUN["prdigest run<br/>deterministic Telegram"]
     C --> FACTS["prdigest facts<br/>versioned JSON"]
     C --> PROSE["prdigest prose<br/>provider-written text"]
     FACTS --> OC[OpenClaw or another client]
     PROSE --> OUT[stdout or explicit Telegram delivery]
 ```
 
-- **Deterministic by default** — repository order, pull-request order, and JSON
-  shape are stable.
-- **AI stays optional** — neither `run` nor `facts` configures or contacts a
-  prose provider.
+- **Stable facts for agents** — repository order, pull-request order, and JSON
+  shape are deterministic.
+- **AI stays explicit** — `facts` never configures or contacts a prose provider.
 - **Safe to resume** — delivery checkpoints prevent already accepted chunks
   from being sent twice.
 - **Secrets stay out of config** — YAML names environment variables; it never
@@ -58,10 +55,9 @@ flowchart LR
 
 | What you need | Command | Result | Side effects |
 |---|---|---|---|
-| Reliable scheduled digest | `prdigest run` | Deterministic Telegram HTML | Reads/writes schedule and delivery state |
-| Facts for OpenClaw or another client | `prdigest facts` | `prdigest-facts` JSON on stdout | No schedule state, Telegram, or AI provider |
+| Facts for OpenClaw or another agent | `prdigest facts` | `prdigest-facts` JSON on stdout | No Telegram, provider, or delivery state |
 | Provider-written text | `prdigest prose` | Plain text on stdout | Fresh run calls GitHub, then the provider; no Telegram or checkpoint |
-| Provider-written Telegram digest | `prdigest prose --deliver` | Checkpointed Telegram delivery | Fresh run calls GitHub and provider, persists, then sends; resume uses the checkpoint without GitHub/provider generation |
+| Scheduled or one-off Telegram prose | `prdigest prose --deliver` | Checkpointed plain-text Telegram delivery | Fresh run calls GitHub and provider, persists, then sends; resume reuses the checkpoint |
 
 All modes accept `--date YYYY-MM-DD` and repeatable
 `--repo OWNER/NAME` overrides. Repository order is always preserved.
@@ -84,7 +80,6 @@ config to state paths writable by your user:
 
 ```yaml
 state:
-  path: tmp/prdigest/state.json
   delivery_path: tmp/prdigest/deliveries
 ```
 
@@ -96,7 +91,7 @@ mode you plan to run:
 
 ```sh
 export GITHUB_TOKEN=github_pat_...
-export TELEGRAM_BOT_TOKEN=...       # run or prose --deliver only
+export TELEGRAM_BOT_TOKEN=...       # prose --deliver only
 export OPENROUTER_API_KEY=...       # prose only; use your configured env name
 ```
 
@@ -107,12 +102,9 @@ allowlisted destination chat.
 ### 2. Try the read-only paths
 
 ```sh
-# Stable JSON: no scheduler state, Telegram, or prose provider
+# Stable JSON: no Telegram, delivery state, or prose provider
 bundle exec prdigest facts --config prdigest.yml
 
-# Deterministic Telegram preview: fetches GitHub but does not send or save state
-bundle exec prdigest run --config prdigest.yml --dry-run
-
 # Provider-written text on stdout: no Telegram or delivery checkpoint
 bundle exec prdigest prose --config prdigest.yml
 ```
@@ -120,9 +112,6 @@ bundle exec prdigest prose --config prdigest.yml
 ### 3. Deliver intentionally
 
 ```sh
-# Scheduled deterministic delivery
-bundle exec prdigest run --config prdigest.yml
-
 # Provider-written delivery, checkpointed before the first Telegram request
 bundle exec prdigest prose --config prdigest.yml --deliver
 ```
@@ -131,7 +120,7 @@ To build and install the current checkout as a gem without publishing it:
 
 ```sh
 gem build prdigest.gemspec
-gem install prdigest-0.2.0.gem
+gem install prdigest-0.3.0.gem
 prdigest version
 ```
 
@@ -167,13 +156,8 @@ github:
     - owner/api
     - owner/web
 
-schedule:
-  max_catchup_days: 7
-
 digest:
   line_stats: true
-  send_empty: true
-  empty_message: "Merged PR digest — {date}\nTotal: 0 PRs"
 
 telegram:
   token_env: TELEGRAM_BOT_TOKEN
@@ -181,7 +165,6 @@ telegram:
   chat_id: -1001234567890
 
 state:
-  path: /var/lib/prdigest/state.json
   delivery_path: /var/lib/prdigest/deliveries
 
 prose:
@@ -198,12 +181,10 @@ annotated configuration.
 <summary><strong>Configuration rules</strong></summary>
 
 - Repository order controls digest order.
-- `max_catchup_days` must be between `1` and `30`.
 - `chat_id` must appear in the non-empty allowlist. Extra IDs are accepted for
   schema compatibility, but delivery sends only to `chat_id`.
 - Token values belong in environment variables, never YAML.
-- The prose block is validated only for `prdigest prose`; it does not ambiently
-  enable provider access for deterministic commands.
+- The prose block is validated only for `prdigest prose`; `facts` ignores it.
 - Remote provider URLs require HTTPS. Plaintext HTTP is accepted only for exact
   loopback hosts.
 
@@ -212,24 +193,11 @@ annotated configuration.
 ## Command reference
 
 ```text
-prdigest run [--config PATH] [--date YYYY-MM-DD] [--dry-run] [--json] [--repo OWNER/NAME ...]
 prdigest facts [--config PATH] [--date YYYY-MM-DD] [--repo OWNER/NAME ...]
 prdigest prose [--config PATH] [--date YYYY-MM-DD] [--repo OWNER/NAME ...] [--deliver]
-prdigest serve
 prdigest version
 ```
 
-### `run`
-
-An ordinary run processes owed dates oldest-first and advances state after each
-settled day. `--date` replays exactly one local date without reading or writing
-the schedule cursor. `--dry-run` previews an explicit date or yesterday and
-constructs neither state nor Telegram delivery.
-
-`--json` emits a versioned `prdigest-result` document with requested, settled,
-skipped, failed, and remaining dates plus delivery progress. `serve` is a
-compatibility stub; use the supplied systemd timer for scheduling.
-
 ### `facts`
 
 Fetches one explicit date or yesterday and prints exactly one JSON document. It
@@ -275,17 +243,17 @@ Sends the same facts document as untrusted data to
 facts without adding to or changing them.
 
 Without `--deliver`, prose is printed to stdout. With `--deliver`, the final
-escaped and chunked payload is stored under `state.delivery_path/prose` before
-the first Telegram request. Provider output containing terminal control
+plain-text chunks are stored under `state.delivery_path/prose` before the first
+Telegram request. Provider output containing terminal control
 characters is rejected before it can reach stdout, a checkpoint, or Telegram.
 
-There is no silent fallback to deterministic prose or another provider.
+There is no silent fallback to another provider.
 
 ## Delivery guarantees
 
 PRDigest treats sending as a durable protocol, not a best-effort loop:
 
-1. Fetch and render the complete day.
+1. Fetch facts and generate the complete prose digest.
 2. Persist the exact final chunk list.
 3. Mark a chunk in flight before sending.
 4. Advance only after Telegram definitely accepts it.
@@ -295,43 +263,26 @@ A definite Telegram 429/5xx response receives at most three attempts. Transport
 failures are ambiguous because Telegram may have accepted the request before
 the connection failed; PRDigest parks them instead of risking a duplicate.
 
-Prose delivery uses its own checkpoint namespace. Once a payload exists, retry
+Once a prose payload exists, retry
 loads those exact chunks before checking GitHub or provider credentials, so a
 resume never regenerates different prose. A failure before the payload becomes
 durable can incur another provider request on retry.
 
 <details>
-<summary><strong>Scheduling, replay, and state details</strong></summary>
+<summary><strong>Date and checkpoint details</strong></summary>
 
 Each local day is converted to independent UTC midnight boundaries, including
-DST gaps and repeats. A day settles only after every chunk succeeds, an enabled
-empty message succeeds, or an empty message is intentionally suppressed.
-
-State is secret-free JSON version 1:
-
-```json
-{"version":1,"timezone":"Europe/London","last_digested_date":"2026-07-15"}
-```
-
-Writes use atomic mode-`0600` replacement and directory fsync. Delivery
-directories are mode `0700`; files and locks are mode `0600`. A per-date lock
-prevents concurrent sends for the same checkpoint.
-
-Missing state means first run and requests yesterday only. Malformed, future,
-unsupported, unreadable, or timezone-mismatched state fails closed.
+DST gaps and repeats. Both commands use yesterday in the configured timezone
+unless `--date YYYY-MM-DD` is supplied.
 
-When backlog exceeds the configured cap, PRDigest durably skips the oldest
-prefix and processes only the newest window. For a timezone migration, stop the
-timer, preserve and move aside the old state, change timezone, explicitly
-replay any required dates, then restart the timer.
+Checkpoint directories are mode `0700`; files and locks are mode `0600`.
+A per-date lock prevents concurrent sends for the same repository scope and
+chat. While a completed checkpoint exists, repeating `prose --deliver` for that
+date is a no-op. Moving that checkpoint aside intentionally allows complete
+regeneration and redelivery.
 
-GitHub does not guarantee search-index freshness. Keep the host timezone aligned
-with the digest timezone and use `--date YYYY-MM-DD` for a delayed merge found
-by a later audit. Explicit replay uses the same delivery ledger: while a
-completed checkpoint for that date exists, delivery is a no-op and newly
-rendered content is ignored. Intentionally archiving the checkpoint makes the
-next replay regenerate and send the complete date, not only the delayed pull
-request.
+The supplied systemd timer invokes `prose --deliver` once each day. PRDigest
+does not maintain a catch-up cursor: explicitly run missed dates with `--date`.
 
 </details>
 
@@ -416,25 +367,24 @@ docker run --rm --env-file /etc/prdigest/.env \
 ### Rollback
 
 Stop the timer, install the prior gem or image, restore its matching config and
-a known-good state backup, then restart. Replay omitted dates explicitly; never
-move a checkpoint forward by hand.
+checkpoint backup, then restart. Never move a checkpoint forward by hand.
 
 ## Exit codes and troubleshooting
 
 | Exit | Meaning | First check |
 |---:|---|---|
-| `0` | Completed or dry-run | — |
+| `0` | Completed | — |
 | `1` | Unexpected or render failure | Logs and input shape |
 | `2` | CLI/configuration refusal | Config path, YAML, timezone, allowlist, env |
 | `3` | GitHub failure | Token scope, repository access, rate/search limits |
 | `4` | Telegram failure | `error.kind` and delivery checkpoint |
-| `5` | State failure | Path, owner, mode, JSON version/date/timezone |
-| `6` | Failure after durable progress | Settled/skipped dates before retry |
+| `5` | Checkpoint state failure | Path, owner, mode, checkpoint JSON |
 | `7` | Provider failure or ambiguous outcome | Endpoint, model, key env, retry cost |
 
 Reconcile `telegram_ambiguous`, `telegram_permanent`, and
-`delivery_checkpoint_permanent` before moving a checkpoint. Concurrent
-scheduled runs are unsupported; the systemd oneshot is the normal coordinator.
+`delivery_checkpoint_permanent` before moving a checkpoint. Overlapping delivery
+for the same date is refused by the checkpoint lock; the systemd oneshot is the
+normal scheduler.
 
 See [`SECURITY.md`](SECURITY.md) for token scope, rotation, and private-data
 flow.

data/SECURITY.md

@@ -35,8 +35,8 @@ and model boundary so OpenClaw can write prose. Standalone `prdigest prose`
 sends the same complete document plus the configured model name to the
 OpenAI-compatible endpoint. Private repositories therefore require an OpenClaw
 deployment or provider whose data handling, retention, and access controls are
-acceptable to the operator. Neither mode is ambient: `prdigest run` and
-`prdigest facts` never contact the standalone prose provider.
+acceptable to the operator. Provider access is never ambient: `prdigest facts`
+does not contact the standalone prose provider.
 
 Pull-request fields are untrusted input. The built-in provider prompt and the
 OpenClaw skill explicitly classify the facts JSON as data, never instructions,
@@ -45,9 +45,8 @@ processing private repository content. The OpenClaw skill must not make a second
 GitHub query, deliver messages, install software silently, or print credentials.
 
 Prose Telegram checkpoints contain generated text derived from repository facts.
-They use the same secret-free mode-`0600` files and mode-`0700` directories as
-deterministic delivery, under a separate `prose` namespace. Protect, retain, and
-delete them as private repository metadata.
+They use secret-free mode-`0600` files inside mode-`0700` directories. Protect,
+retain, and delete them as private repository metadata.
 
 ## Reporting
 

data/configs/config.example.yml

@@ -1,12 +1,6 @@
-# prdigest — multi-repo merged-PR daily digest (Hive-independent)
+# prdigest — merged-PR facts for agents and provider-written prose
 
 timezone: Europe/London
-schedule:
-  # Prefer systemd timer + `prdigest run` for v1.
-  # serve mode may honor this later.
-  cron: "5 9 * * *"
-  # Newest retained catch-up window; valid range is 1..30.
-  max_catchup_days: 7
 
 github:
   token_env: GITHUB_TOKEN
@@ -23,11 +17,9 @@ telegram:
 
 digest:
   line_stats: true
-  send_empty: true
-  empty_message: "Merged PR digest — {date}\nTotal: 0 PRs"
 
 prose:
-  # Used only by `prdigest prose`; `run` and `facts` never contact this endpoint.
+  # Used only by `prdigest prose`; `facts` never contacts this endpoint.
   provider: openai_compatible
   base_url: https://openrouter.ai/api/v1
   # Replace with a model identifier accepted by the configured endpoint.
@@ -36,6 +28,5 @@ prose:
   api_key_env: OPENROUTER_API_KEY
 
 state:
-  path: /var/lib/prdigest/state.json
-  # Stable rendered chunks and next-unsent position, separate from the date cursor.
+  # Stable prose chunks and the next-unsent position.
   delivery_path: /var/lib/prdigest/deliveries

data/lib/prdigest/cli.rb

@@ -8,9 +8,15 @@ module Prdigest
   class CLI < Thor
     class ParseError < StandardError; end
 
-    desc "run", "Build and send (or dry-run) a merged-PR digest for one local day"
-    def run_cmd; end
-    map "run" => :run_cmd
+    EXIT_CODES = {
+      "config" => 2, "cli" => 2, "refusal" => 2,
+      "github" => 3,
+      "telegram" => 4, "telegram_refused" => 4, "telegram_permanent" => 4,
+      "telegram_ambiguous" => 4, "delivery_checkpoint" => 4,
+      "delivery_checkpoint_permanent" => 4,
+      "state" => 5,
+      "provider" => 7, "provider_ambiguous" => 7
+    }.freeze
 
     desc "facts", "Print deterministic merged-PR facts as JSON"
     def facts; end
@@ -21,14 +27,10 @@ module Prdigest
     desc "version", "Print version"
     def version; end
 
-    desc "serve", "Compatibility stub; use the systemd timer"
-    def serve; end
-
     class << self
       def invoke(argv = ARGV, out: $stdout, err: $stderr, env: ENV,
-                 system_path: "/etc/prdigest/config.yml", runner_factory: nil,
-                 facts_runner_factory: nil, prose_runner_factory: nil)
-        json_intent = Array(argv).any? { |arg| arg == "--json" || arg.start_with?("--json=") }
+                 system_path: "/etc/prdigest/config.yml", facts_runner_factory: nil,
+                 prose_runner_factory: nil)
         intent = command_intent(argv)
         facts_intent = intent == "facts"
         prose_intent = intent == "prose"
@@ -38,17 +40,11 @@ module Prdigest
         raise ParseError, "--help is not valid for facts" if facts_intent && parsed[:command] == "help"
         return print_help(out) if %w[help --help -h].include?(parsed[:command])
 
-        unless %w[facts prose run serve].include?(parsed[:command])
-          raise ParseError, "unknown command"
-        end
+        raise ParseError, "unknown command" unless %w[facts prose].include?(parsed[:command])
 
         path = Config.resolve_path(explicit: parsed[:config], env: env, system_path: system_path)
         capability = config_capability(parsed)
         config = Config.load(path, capability: capability)
-        if parsed[:command] == "serve"
-          err.puts "prdigest serve: not implemented — use systemd timer + `prdigest run`"
-          return 0
-        end
 
         validate_date!(parsed[:date]) if parsed[:date]
         repositories = if parsed[:repos].empty?
@@ -91,36 +87,16 @@ module Prdigest
           present_prose(outcome, out: out)
           return 0
         end
-
-        raise ConfigError, "GitHub token is missing" if config.github_token(env).empty?
-        if !parsed[:dry_run] && config.telegram_token(env).empty?
-          raise ConfigError, "Telegram bot token is missing"
-        end
-
-        factory = runner_factory || ->(**options) { Runner.new(**options) }
-        result = factory.call(
-          config: config,
-          date: parsed[:date],
-          dry_run: parsed[:dry_run],
-          repositories: repositories,
-          env: env
-        ).call
-        present(result, json: parsed[:json], out: out, err: err)
-        result.exit_code
       rescue ParseError => e
         return present_facts_failure(out, "cli", e.message) if facts_intent
         return present_prose_failure(err, "cli", e.message) if prose_intent
 
-        result = Result.failure(mode: "scheduled", error_kind: "cli", message: e.message)
-        present(result, json: json_intent, out: out, err: err)
-        result.exit_code
+        present_cli_failure(err, "cli", e.message)
       rescue ConfigError => e
         return present_facts_failure(out, "config", e.message) if facts_intent
         return present_prose_failure(err, "config", safe_prose_message(e, config: config, env: env)) if prose_intent
 
-        result = Result.failure(mode: parsed && parsed[:date] ? "explicit_date_replay" : "scheduled", error_kind: "config", message: e.message)
-        present(result, json: parsed ? parsed[:json] : json_intent, out: out, err: err)
-        result.exit_code
+        present_cli_failure(err, "config", e.message)
       rescue StandardError => e
         if facts_intent
           kind = e.is_a?(FetchError) ? e.kind : "internal"
@@ -133,13 +109,7 @@ module Prdigest
           return present_prose_failure(err, kind, message)
         end
 
-        result = Result.failure(
-          mode: parsed && parsed[:date] ? "explicit_date_replay" : "scheduled",
-          error_kind: "internal",
-          message: "unexpected CLI failure (#{e.class})"
-        )
-        present(result, json: parsed ? parsed[:json] : json_intent, out: out, err: err)
-        result.exit_code
+        present_cli_failure(err, "internal", "unexpected CLI failure (#{e.class})")
       end
 
       alias start invoke
@@ -242,13 +212,12 @@ module Prdigest
         case parsed.fetch(:command)
         when "facts" then :facts
         when "prose" then parsed[:deliver] ? :prose_delivery : :prose
-        else :run
         end
       end
 
       def present_facts_failure(out, error_kind, message)
         out.puts JSON.generate(Facts.failure(error_kind: error_kind, message: message))
-        Result::EXIT_CODES.fetch(error_kind.to_s, 1)
+        EXIT_CODES.fetch(error_kind.to_s, 1)
       end
 
       def present_prose(outcome, out:)
@@ -265,7 +234,12 @@ module Prdigest
 
       def present_prose_failure(err, error_kind, message)
         err.puts "prdigest: #{error_kind}: #{message}"
-        Result::EXIT_CODES.fetch(error_kind.to_s, 1)
+        EXIT_CODES.fetch(error_kind.to_s, 1)
+      end
+
+      def present_cli_failure(err, error_kind, message)
+        err.puts "prdigest: #{error_kind}: #{message}"
+        EXIT_CODES.fetch(error_kind.to_s, 1)
       end
 
       def prose_error_kind(error)
@@ -293,39 +267,15 @@ module Prdigest
         end
       end
 
-      def present(result, json:, out:, err:)
-        if json
-          out.puts JSON.generate(result.to_h)
-        elsif result.exit_code.zero?
-          if result.status == "dry_run"
-            out.puts result.chunks.join("\n\n")
-          else
-            out.puts "prdigest: success; settled=#{result.settled_days.length} skipped=#{result.skipped_days.length}"
-          end
-        else
-          if result.status == "partial_failure"
-            err.puts "prdigest: progress; settled=#{human_dates(result.settled_days)} " \
-                     "skipped=#{human_dates(result.skipped_days)} remaining=#{human_dates(result.remaining_days)}"
-          end
-          err.puts "prdigest: #{result.error[:kind]}: #{result.error[:message]}"
-        end
-      end
-
-      def human_dates(dates)
-        values = Array(dates)
-        values.empty? ? "none" : values.join(",")
-      end
-
       def print_version(out)
         out.puts "prdigest #{VERSION}"
         0
       end
 
       def print_help(out)
-        out.puts "Usage: prdigest run [--config PATH] [--date YYYY-MM-DD] [--repo owner/name] [--dry-run] [--json]"
-        out.puts "       prdigest facts [--config PATH] [--date YYYY-MM-DD] [--repo owner/name]"
+        out.puts "Usage: prdigest facts [--config PATH] [--date YYYY-MM-DD] [--repo owner/name]"
         out.puts "       prdigest prose [--config PATH] [--date YYYY-MM-DD] [--repo owner/name] [--deliver]"
-        out.puts "       prdigest serve | version"
+        out.puts "       prdigest version"
         0
       end
     end

data/lib/prdigest/config.rb

@@ -28,7 +28,7 @@ module Prdigest
       raise ConfigError, "config path is required (--config, PRDIGEST_CONFIG, or /etc/prdigest/config.yml)"
     end
 
-    def self.load(path, capability: :run)
+    def self.load(path, capability: :facts)
       path = File.expand_path(path)
       raise ConfigError, "config not found: #{path}" unless File.file?(path)
 
@@ -143,35 +143,13 @@ module Prdigest
       raw.dig("digest", "line_stats") != false
     end
 
-    def send_empty?
-      raw.dig("digest", "send_empty") != false
-    end
-
-    def empty_message
-      raw.dig("digest", "empty_message") || "Merged PR digest — {date}\nTotal: 0 PRs"
-    end
-
-    def state_path
-      raw.dig("state", "path") || File.expand_path("~/.local/share/prdigest/state.json")
-    end
-
     def delivery_state_path
-      raw.dig("state", "delivery_path") || File.join(File.dirname(state_path), "deliveries")
+      raw.dig("state", "delivery_path") || File.expand_path("~/.local/share/prdigest/deliveries")
     end
 
-    def schedule_cron
-      raw.dig("schedule", "cron") || "5 9 * * *"
-    end
-
-    def max_catchup_days
-      Integer(raw.dig("schedule", "max_catchup_days") || 7)
-    rescue TypeError, ArgumentError
-      raise ConfigError, "schedule.max_catchup_days must be an integer from 1 to 30"
-    end
-
-    def validate!(capability: :run)
+    def validate!(capability: :facts)
       capability = capability.to_sym
-      unless %i[facts run prose prose_delivery].include?(capability)
+      unless %i[facts prose prose_delivery].include?(capability)
         raise ArgumentError, "unknown configuration capability: #{capability}"
       end
 
@@ -180,9 +158,6 @@ module Prdigest
       rescue TZInfo::InvalidTimezoneIdentifier
         raise ConfigError, "timezone must be a resolvable IANA identifier"
       end
-      unless (1..30).cover?(max_catchup_days)
-        raise ConfigError, "schedule.max_catchup_days must be from 1 to 30"
-      end
       repos
       return self if capability == :facts
 

data/lib/prdigest/prose_renderer.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require "cgi"
-
 module Prdigest
   class ProseRenderer
+    Output = Data.define(:chunks, :outcome)
     DISALLOWED_CONTROL_CHARACTERS = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/
 
     def initialize(limit: 4_096)
@@ -23,10 +22,8 @@ module Prdigest
         )
       end
 
-      chunks = text.each_char.each_slice(@limit).map do |characters|
-        CGI.escapeHTML(characters.join).freeze
-      end
-      Renderer::Output.new(chunks.freeze, "rendered")
+      chunks = text.each_char.each_slice(@limit).map { |characters| characters.join.freeze }
+      Output.new(chunks.freeze, "rendered")
     rescue RenderError
       raise
     rescue StandardError => e

data/lib/prdigest/telegram.rb

@@ -109,7 +109,6 @@ module Prdigest
       request.body = JSON.generate(
         chat_id: @chat_id,
         text: text,
-        parse_mode: "HTML",
         link_preview_options: { is_disabled: true }
       )
       request

data/lib/prdigest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prdigest
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/prdigest.rb

@@ -48,13 +48,8 @@ require_relative "prdigest/collector"
 require_relative "prdigest/facts"
 require_relative "prdigest/facts_runner"
 require_relative "prdigest/openai_compatible"
-require_relative "prdigest/renderer"
 require_relative "prdigest/prose_renderer"
 require_relative "prdigest/delivery_checkpoint_store"
 require_relative "prdigest/telegram"
 require_relative "prdigest/prose_runner"
-require_relative "prdigest/result"
-require_relative "prdigest/schedule"
-require_relative "prdigest/state"
-require_relative "prdigest/runner"
 require_relative "prdigest/cli"

data/scripts/systemd/prdigest.service

@@ -8,7 +8,7 @@ Type=oneshot
 User=prdigest
 Group=prdigest
 EnvironmentFile=/etc/prdigest/.env
-ExecStart=/usr/local/bin/prdigest run --config /etc/prdigest/config.yml
+ExecStart=/usr/local/bin/prdigest prose --config /etc/prdigest/config.yml --deliver
 StateDirectory=prdigest
 StateDirectoryMode=0700
 UMask=0077

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prdigest
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ivan Kuznetsov
@@ -127,8 +127,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.25'
-description: Config-driven GitHub merged-PR facts with deterministic Telegram delivery
-  and optional OpenAI-compatible prose. Hive-independent and secret-safe.
+description: Config-driven GitHub merged-PR facts for agents plus OpenAI-compatible
+  prose for stdout or checkpointed Telegram delivery.
 email:
 - ivan@ikuznetsov.com
 executables:
@@ -155,11 +155,6 @@ files:
 - lib/prdigest/openai_compatible.rb
 - lib/prdigest/prose_renderer.rb
 - lib/prdigest/prose_runner.rb
-- lib/prdigest/renderer.rb
-- lib/prdigest/result.rb
-- lib/prdigest/runner.rb
-- lib/prdigest/schedule.rb
-- lib/prdigest/state.rb
 - lib/prdigest/telegram.rb
 - lib/prdigest/version.rb
 - scripts/systemd/prdigest.service
@@ -188,5 +183,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Deterministic multi-repo merged-PR facts and digests
+summary: Merged-PR facts for agents and provider-written prose
 test_files: []

data/lib/prdigest/renderer.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-
-module Prdigest
-  class Renderer
-    Output = Data.define(:chunks, :outcome)
-    SUPPORTED_TAG = %r{</?(?:b|a)(?:\s+href="[^"]*")?>}.freeze
-
-    def self.parsed_length(html)
-      CGI.unescapeHTML(html.gsub(SUPPORTED_TAG, "")).length
-    end
-
-    def initialize(send_empty:, empty_message:, limit: 4_096)
-      @send_empty = send_empty
-      @empty_message = empty_message.to_s
-      @limit = Integer(limit)
-    end
-
-    def render(digest)
-      return render_empty(digest) if digest.total_prs.zero?
-
-      pack(digest)
-    rescue RenderError
-      raise
-    rescue StandardError => e
-      raise RenderError, "digest rendering failed: #{e.class}"
-    end
-
-    private
-
-    def render_empty(digest)
-      return Output.new([].freeze, "suppressed_empty") unless @send_empty
-
-      text = escape(@empty_message.gsub("{date}", digest.date.iso8601))
-      raise RenderError, "configured empty message exceeds Telegram limit" unless fits_text?(text)
-      Output.new([text.freeze].freeze, "rendered")
-    end
-
-    def pack(digest)
-      chunks = []
-      heading = "<b>Merged PR digest — #{digest.date.iso8601}</b>"
-      continuation = "<b>Merged PR digest — #{digest.date.iso8601} (cont.)</b>"
-      current = [heading]
-
-      digest.repositories.each do |section|
-        next if section.pull_requests.empty?
-        current = add_section(chunks, current, continuation, section)
-      end
-
-      footer = render_footer(digest)
-      unless fits_parts?(current + [footer])
-        flush!(chunks, current)
-        current = [continuation, footer]
-        raise RenderError, "digest footer exceeds Telegram limit" unless fits_parts?(current)
-      else
-        current << footer
-      end
-      flush!(chunks, current)
-      Output.new(chunks.map(&:freeze).freeze, "rendered")
-    end
-
-    def add_section(chunks, current, continuation, section)
-      header = "<b>#{escape(section.name)}</b>"
-      entries = section.pull_requests.map { |pull| render_pull(pull) }
-      whole = ([header] + entries).join("\n")
-      if fits_parts?(current + [whole])
-        current << whole
-        return current
-      end
-
-      if current.length > 1
-        flush!(chunks, current)
-        current = [continuation]
-        if fits_parts?(current + [whole])
-          current << whole
-          return current
-        end
-      end
-
-      section_part = header
-      entries.each do |entry|
-        proposed = "#{section_part}\n#{entry}"
-        if fits_parts?(current + [proposed])
-          section_part = proposed
-          next
-        end
-
-        if section_part == header
-          raise RenderError, "pull request entry exceeds Telegram limit"
-        end
-        current << section_part
-        flush!(chunks, current)
-        current = [continuation]
-        section_part = "<b>#{escape(section.name)} (cont.)</b>\n#{entry}"
-        raise RenderError, "pull request entry exceeds Telegram limit" unless fits_parts?(current + [section_part])
-      end
-      current << section_part
-      current
-    end
-
-    def render_pull(pull)
-      number_and_title = "##{pull.number} #{pull.title}"
-      "• <a href=\"#{escape(pull.url)}\">#{escape(number_and_title)}</a> — @#{escape(pull.author)}"
-    end
-
-    def render_footer(digest)
-      label = digest.total_prs == 1 ? "PR" : "PRs"
-      footer = "<b>Total:</b> #{digest.total_prs} #{label}"
-      if digest.line_stats
-        footer += " · +#{digest.total_additions}/−#{digest.total_deletions} · #{digest.total_commits} commits"
-      end
-      footer
-    end
-
-    def flush!(chunks, parts)
-      text = parts.join("\n\n")
-      raise RenderError, "rendered chunk exceeds Telegram limit" unless fits_text?(text)
-      chunks << text
-    end
-
-    def fits_parts?(parts)
-      fits_text?(parts.join("\n\n"))
-    end
-
-    def fits_text?(text)
-      self.class.parsed_length(text) <= @limit
-    end
-
-    def escape(value)
-      CGI.escapeHTML(value.to_s)
-    end
-  end
-end

data/lib/prdigest/result.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Prdigest
-  class Result
-    SCHEMA = "prdigest-result"
-    SCHEMA_VERSION = 1
-    REQUIRED_FIELDS = %i[
-      status mode requested_days settled_days skipped_days failed_date remaining_days error
-    ].freeze
-    EXIT_CODES = {
-      "config" => 2, "cli" => 2, "refusal" => 2,
-      "github" => 3,
-      "telegram" => 4, "telegram_refused" => 4, "telegram_permanent" => 4,
-      "telegram_ambiguous" => 4, "delivery_checkpoint" => 4,
-      "delivery_checkpoint_permanent" => 4,
-      "state" => 5,
-      "provider" => 7, "provider_ambiguous" => 7
-    }.freeze
-
-    attr_reader(*REQUIRED_FIELDS, :chunks, :delivery)
-
-    def initialize(status:, mode:, requested_days: [], settled_days: [], skipped_days: [],
-                   failed_date: nil, remaining_days: [], error: nil, chunks: [], delivery: nil)
-      @status = status.to_s.freeze
-      @mode = mode.to_s.freeze
-      @requested_days = Array(requested_days).freeze
-      @settled_days = Array(settled_days).freeze
-      @skipped_days = Array(skipped_days).freeze
-      @failed_date = failed_date
-      @remaining_days = Array(remaining_days).freeze
-      @error = error&.transform_keys(&:to_sym)&.freeze
-      @chunks = Array(chunks).map(&:to_s).freeze
-      @delivery = delivery&.transform_keys(&:to_sym)&.freeze
-      freeze
-    end
-
-    def self.failure(mode:, error_kind:, message:, requested_days: [], settled_days: [], skipped_days: [],
-                     failed_date: nil, remaining_days: [], chunks: [], delivery: nil)
-      progress = !settled_days.empty? || !skipped_days.empty?
-      new(
-        status: progress ? "partial_failure" : "failure",
-        mode: mode,
-        requested_days: requested_days,
-        settled_days: settled_days,
-        skipped_days: skipped_days,
-        failed_date: failed_date,
-        remaining_days: remaining_days,
-        error: { kind: error_kind.to_s, message: message.to_s },
-        chunks: chunks,
-        delivery: delivery
-      )
-    end
-
-    def exit_code
-      return 0 if %w[success dry_run].include?(status)
-      return 6 if status == "partial_failure"
-      EXIT_CODES.fetch(error && error[:kind], 1)
-    end
-
-    def to_h
-      {
-        schema: SCHEMA,
-        schema_version: SCHEMA_VERSION,
-        status: status,
-        mode: mode,
-        requested_days: serialize_dates(requested_days),
-        settled_days: serialize_dates(settled_days),
-        skipped_days: serialize_dates(skipped_days),
-        failed_date: failed_date&.to_s,
-        remaining_days: serialize_dates(remaining_days),
-        error: error,
-        chunks: chunks,
-        delivery: delivery
-      }
-    end
-
-    private
-
-    def serialize_dates(values)
-      values.map(&:to_s)
-    end
-  end
-end

data/lib/prdigest/runner.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Prdigest
-  class Runner
-    def initialize(config:, date: nil, dry_run: false, clock: nil, state_factory: nil,
-                   github: nil, renderer: nil, telegram_factory: nil, repositories: nil, env: ENV)
-      @config = config
-      @date = date && Date.iso8601(date.to_s)
-      @dry_run = dry_run
-      @clock = clock || Clock.new(timezone: config.timezone)
-      @state_factory = state_factory || -> { State.new(path: config.state_path, timezone: config.timezone) }
-      @env = env
-      @repositories = repositories || config.repos
-      @collector = Collector.new(
-        clock: @clock,
-        github: github || GitHub.new(token: config.github_token(env)),
-        repositories: @repositories,
-        line_stats: config.line_stats?
-      )
-      @renderer = renderer || Renderer.new(send_empty: config.send_empty?, empty_message: config.empty_message)
-      @delivery_checkpoint_store_factory = lambda {
-        DeliveryCheckpointStore.new(root: config.delivery_state_path)
-      }
-      @telegram_factory = telegram_factory || lambda {
-        Telegram.new(
-          token: config.telegram_token(env),
-          chat_id: config.chat_id,
-          allowlist: config.chat_id_allowlist
-        )
-      }
-    end
-
-    def call
-      mode = @date ? "explicit_date_replay" : "scheduled"
-      requested = []
-      settled = []
-      skipped = []
-      chunks = []
-      failed_date = nil
-      delivery = nil
-      state = nil
-      skip_audit = nil
-
-      if @dry_run || @date
-        requested = [@date || @clock.yesterday]
-      else
-        state = @state_factory.call
-        yesterday = @clock.yesterday
-        record = state.read(yesterday: yesterday)
-        skip_audit = record.last_skip
-        skipped.concat(expand_skip(skip_audit)) if skip_audit && skip_audit[:notice_pending]
-        schedule = Schedule.new(
-          yesterday: yesterday,
-          last_digested_date: record.last_digested_date,
-          max_catchup_days: @config.max_catchup_days
-        ).call
-        requested = schedule.requested_days
-        unless schedule.skipped_days.empty?
-          skip_audit = merge_skip_audit(skip_audit, schedule.skipped_days)
-          state.write(last_digested_date: schedule.skipped_days.last, last_skip: skip_audit)
-          skipped |= schedule.skipped_days
-        end
-      end
-
-      telegram = nil
-      requested.each do |date|
-        failed_date = date
-        digest = @collector.call(date: date)
-        rendered = @renderer.render(digest)
-        if @dry_run
-          chunks.concat(rendered.chunks)
-          next
-        end
-
-        unless rendered.chunks.empty?
-          telegram ||= @telegram_factory.call
-          delivery = telegram.deliver(
-            rendered.chunks,
-            digest_date: date,
-            checkpoint_store: @delivery_checkpoint_store_factory.call,
-            scope: @repositories
-          )
-        end
-        if state
-          if skip_audit
-            skip_audit = skip_audit.merge(notice_pending: false)
-          end
-          state.write(last_digested_date: date, last_skip: skip_audit)
-        end
-        settled << date
-        failed_date = nil
-      end
-
-      Result.new(
-        status: @dry_run ? "dry_run" : "success",
-        mode: mode,
-        requested_days: requested,
-        settled_days: settled,
-        skipped_days: skipped,
-        chunks: chunks,
-        delivery: delivery
-      )
-    rescue StandardError => e
-      Result.failure(
-        mode: mode || (@date ? "explicit_date_replay" : "scheduled"),
-        error_kind: error_kind(e),
-        message: safe_message(e),
-        requested_days: requested || [],
-        settled_days: settled || [],
-        skipped_days: skipped || [],
-        failed_date: failed_date,
-        remaining_days: remaining_days(requested || [], failed_date),
-        chunks: chunks || [],
-        delivery: e.is_a?(SendError) ? e.delivery : delivery
-      )
-    end
-
-    def inspect
-      "#<#{self.class} mode=#{@date ? "explicit_date_replay" : "scheduled"} " \
-        "dry_run=#{@dry_run} credentials=[REDACTED]>"
-    end
-
-    alias to_s inspect
-
-    private
-
-    def expand_skip(audit)
-      return [] unless audit
-      (audit.fetch(:start_date)..audit.fetch(:end_date)).to_a
-    end
-
-    def merge_skip_audit(existing, dates)
-      start_date = if existing && existing[:notice_pending]
-                     [existing[:start_date], dates.first].min
-                   else
-                     dates.first
-                   end
-      { start_date: start_date, end_date: dates.last, notice_pending: true }
-    end
-
-    def remaining_days(requested, failed_date)
-      return requested unless failed_date
-      index = requested.index(failed_date)
-      index ? requested.drop(index) : [failed_date]
-    end
-
-    def error_kind(error)
-      case error
-      when ConfigError then "config"
-      when FetchError then error.kind
-      when SendError then error.kind
-      when StateError then "state"
-      when RenderError then error.kind
-      else "internal"
-      end
-    end
-
-    def safe_message(error)
-      message = error.is_a?(Error) ? error.message : "unexpected failure (#{error.class})"
-      secrets = []
-      secrets << @config.github_token(@env) if @config.respond_to?(:github_token)
-      secrets << @config.telegram_token(@env) if @config.respond_to?(:telegram_token)
-      secrets.compact.reject(&:empty?).reduce(message.dup) { |safe, secret| safe.gsub(secret, "[REDACTED]") }
-    end
-  end
-end

data/lib/prdigest/schedule.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Prdigest
-  class Schedule
-    Result = Data.define(:skipped_days, :requested_days)
-
-    def initialize(yesterday:, last_digested_date:, max_catchup_days:)
-      @yesterday = Date.iso8601(yesterday.to_s)
-      @last_digested_date = last_digested_date && Date.iso8601(last_digested_date.to_s)
-      @max_catchup_days = Integer(max_catchup_days)
-    end
-
-    def call
-      raise ArgumentError, "max_catchup_days must be from 1 to 30" unless (1..30).cover?(@max_catchup_days)
-      raise ArgumentError, "last digested date is in the future" if @last_digested_date && @last_digested_date > @yesterday
-
-      owed = if @last_digested_date.nil?
-               [@yesterday]
-             elsif @last_digested_date == @yesterday
-               []
-             else
-               ((@last_digested_date + 1)..@yesterday).to_a
-             end
-      split = [owed.length - @max_catchup_days, 0].max
-      Result.new(owed.first(split).freeze, owed.drop(split).freeze)
-    end
-  end
-end

data/lib/prdigest/state.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "fileutils"
-require "json"
-require "securerandom"
-
-module Prdigest
-  class State
-    VERSION = 1
-    Record = Data.define(:last_digested_date, :last_skip)
-
-    def initialize(path:, timezone:, rename: File.method(:rename), directory_sync: nil)
-      @path = File.expand_path(path)
-      @timezone = timezone
-      @rename = rename
-      @directory_sync = directory_sync || method(:sync_directory)
-    end
-
-    def read(yesterday: nil)
-      return Record.new(nil, nil) unless File.exist?(@path)
-
-      payload = JSON.parse(File.binread(@path))
-      validate_payload!(payload, yesterday: yesterday)
-    rescue StateError
-      raise
-    rescue StandardError => e
-      raise StateError, "cannot read state: #{e.class}"
-    end
-
-    def write(last_digested_date:, last_skip: nil)
-      directory = File.dirname(@path)
-      FileUtils.mkdir_p(directory, mode: 0o700)
-      temp_path = File.join(directory, ".#{File.basename(@path)}.tmp-#{SecureRandom.hex(8)}")
-      payload = JSON.generate(serialize(last_digested_date, last_skip)) << "\n"
-
-      File.open(temp_path, File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
-        file.write(payload)
-        file.chmod(0o600)
-        file.flush
-        file.fsync
-      end
-      rollback_path = preserve_previous_checkpoint(directory)
-      @rename.call(temp_path, @path)
-      begin
-        @directory_sync.call(directory)
-      rescue StandardError
-        restore_previous_checkpoint(rollback_path)
-        raise
-      end
-      Record.new(Date.iso8601(last_digested_date.to_s), normalize_skip(last_skip))
-    rescue StandardError => e
-      raise StateError, "cannot write state: #{e.class}"
-    ensure
-      File.unlink(temp_path) if defined?(temp_path) && temp_path && File.exist?(temp_path)
-      discard_rollback(rollback_path) if defined?(rollback_path) && rollback_path
-    end
-
-    private
-
-    def sync_directory(directory)
-      File.open(directory, File::RDONLY) { |dir| dir.fsync }
-    end
-
-    def preserve_previous_checkpoint(directory)
-      rollback_path = File.join(directory, ".#{File.basename(@path)}.rollback-#{SecureRandom.hex(8)}")
-      File.link(@path, rollback_path)
-      rollback_path
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def restore_previous_checkpoint(rollback_path)
-      if rollback_path
-        File.rename(rollback_path, @path)
-      else
-        File.unlink(@path)
-      end
-    rescue Errno::ENOENT
-      raise if rollback_path
-      nil
-    end
-
-    def discard_rollback(rollback_path)
-      FileUtils.rm_f(rollback_path) if rollback_path
-    end
-
-    def validate_payload!(payload, yesterday:)
-      raise StateError, "state root must be an object" unless payload.is_a?(Hash)
-      raise StateError, "unsupported state version" unless payload["version"] == VERSION
-      raise StateError, "state timezone does not match config" unless payload["timezone"] == @timezone
-      raise StateError, "state last_digested_date is required" unless payload.key?("last_digested_date")
-
-      value = payload["last_digested_date"]
-      last_date = Date.iso8601(value)
-      raise StateError, "state date is in the future" if yesterday && last_date && last_date > Date.iso8601(yesterday.to_s)
-
-      skip = parse_skip(payload["last_skip"])
-      if skip && (skip[:start_date] > skip[:end_date] || skip[:end_date] > last_date)
-        raise StateError, "state last_skip range is invalid"
-      end
-      Record.new(last_date, skip)
-    rescue Date::Error, TypeError
-      raise StateError, "state contains an invalid date"
-    end
-
-    def parse_skip(value)
-      return nil if value.nil?
-      raise StateError, "state last_skip is invalid" unless value.is_a?(Hash)
-
-      pending = value.fetch("notice_pending")
-      raise StateError, "state last_skip is invalid" unless pending == true || pending == false
-      {
-        start_date: Date.iso8601(value.fetch("start_date")),
-        end_date: Date.iso8601(value.fetch("end_date")),
-        notice_pending: pending
-      }
-    rescue KeyError
-      raise StateError, "state last_skip is invalid"
-    end
-
-    def normalize_skip(skip)
-      return nil unless skip
-      {
-        start_date: Date.iso8601(skip.fetch(:start_date).to_s),
-        end_date: Date.iso8601(skip.fetch(:end_date).to_s),
-        notice_pending: skip.fetch(:notice_pending) == true
-      }
-    end
-
-    def serialize(last_date, last_skip)
-      payload = {
-        version: VERSION,
-        timezone: @timezone,
-        last_digested_date: Date.iso8601(last_date.to_s).iso8601
-      }
-      if (skip = normalize_skip(last_skip))
-        payload[:last_skip] = {
-          start_date: skip[:start_date].iso8601,
-          end_date: skip[:end_date].iso8601,
-          notice_pending: skip[:notice_pending]
-        }
-      end
-      payload
-    end
-  end
-end