bible270 0.18.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1717282682f9d19a378cd4416b50e5e3f3b63d110e855196042a6e090ed4bd92
-  data.tar.gz: '0812f617706046de930ba84e4cfb6747fc73195b79818a05db11ae0e29484f6b'
+  metadata.gz: 167d9d42022755b068edda39ff37a00b1a159b05c2d0fadcce80173f1f4c6e7d
+  data.tar.gz: 2a97a8eab487cff56dc465e4e81eda2e4a63c60afde87f10f2ad018891cec67b
 SHA512:
-  metadata.gz: 4d1fa7576be664152a2a64e5af1749e39d77fb6b7cd26ca5198a5017727c160e4a413a6337b4c222e7bf727a037fbcb56ea21972034712cf4da087e93e0a8636
-  data.tar.gz: 89223b4dd7dbed64af6b4e4d90cbd3bb0e6b74c85b9b0b56baf64c9d8aa833710325965d43067a89dac67b754ad87bf192cc49a7996e2066daf0e3b82b164b36
+  metadata.gz: 0a8b0d0c963c24be7acfef4301be2ccbb2d95157a6aaa3177a42968a08e893e689ed0d747dce3375c02f3c912f1b23d4f69738659a96f3587d41cdb8bf2cd66c
+  data.tar.gz: 52dab82161413ee0aceecd4a67cd0a30411d36d0c4d3c6eeb03a6ea36e3ba98a754d29d36772c7e29aa5297bba31f323d1c19f17b68bc85ac6f154275b40569a

data/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to bible270. Format follows [Keep a Changelog](https://keepa
 
 ## Unreleased Changes
 
+### Added
+
+- recovery choices for readers whose next unfinished reading is behind the community day, including an optional schedule reset that preserves progress and reflections
+- a two-worker default `test` task with real-time colorized progress, one aggregate result and duration, merged coverage, a browsable project-local `coverage/` report, and per-file runtime recording, plus `test:serial` when a serial run is needed
+- browser-local reflection and reply drafts that survive refreshes, failed submissions, and accidental navigation
+- day and author filters, pagination, and new-activity markers on the Reflections page
+
+### Changed
+
+- replace progress-ranked community lists with transparent recent-participation and alphabetical views that emphasize reading together
+- make Progress actionable with partial-day links, a calendar-week summary, and the reader's next milestone
+- improve accessibility with AA text contrast, consistent focus indicators, descriptive day-grid labels, semantic boundary navigation, touch-friendly tooltips, responsive forms, and reduced-motion support
+- keep profiles and scheduled jobs available while a newly installed daily-reminder database migration is pending
+- add consistent pending, success, and retry feedback to reading, like, reflection, and reply actions, with repeat-safe checkoff and like requests
+- add a remembered compact reading mode that keeps passages, checkoffs, navigation, and completion next steps in focus
+
 See the changes since the last release:
 
 **[Full Changelog](https://github.com/avonderluft/bible270/compare/v0.18.2...main)**

data/README.md

@@ -24,6 +24,12 @@ The schedule is pure deterministic Ruby (`Bible270::Plan`) — none of it is sto
 - **Rails** >= 7.0. On Ruby 4.0 your host app is the real constraint, not this engine — check your lockfile with RailsBump first.
 - A host app, and Turbo if you want check-offs without a page reload.
 
+Mutation controls expose pending, success, and retry feedback when JavaScript runs, while ordinary HTML
+forms remain the fallback. Repeated checkoff and like requests converge on the intended state rather
+than accidentally reversing it. Day pages also offer a browser-local **Compact reading** preference
+that keeps passages, checkoffs, day navigation, and the completion next step while hiding community
+and reflection content.
+
 ## Install
 
 ```ruby
@@ -272,6 +278,19 @@ Admins get an extra "Admin" link in the header. From a reader's page you can:
   written; hiding one takes it off the day and community pages without deleting it, and is
   reversible. Delete is there too, for anything that shouldn't be kept.
 
+The Reflections page lists conversations by their latest approved reply, supports day and author
+filters, and paginates older threads. Signed-in readers see which conversations became active since
+their previous visit. Reflection and reply drafts are retained for up to 30 days in that browser and
+cleared after a successful post. On a shared device, clearing browser storage also removes saved drafts.
+
+After upgrading, copy and run migration `20260101000017`, which stores each reader's last visit to the
+Reflections page:
+
+```bash
+bin/rails bible270:install:migrations
+bin/rails db:migrate
+```
+
 Break points can also live in your app rather than the gem, and be changed without a restart:
 
 ```ruby
@@ -313,6 +332,38 @@ Bible270::Plan.day_for(date, start, clamp: false) # => -3 or 271, to spot out-of
 Bible270::Plan.before_start?(date, start)
 ```
 
+## Daily reading reminders
+
+Daily reminders are optional at both levels: the host enables the feature, then each reader chooses
+whether to receive it and at what local time from their profile. The feature and reader opt-in both
+default to off; each reader's time defaults to `08:00`.
+
+```ruby
+# config/initializers/bible270.rb
+Bible270.configure do |config|
+  config.daily_reminders = true
+  config.mailer_from = "no-reply@yourdomain.com"
+  config.mailer_host = "yourdomain.com" # builds links back to the day and profile
+end
+```
+
+After upgrading, copy and run migration `20260101000016`, which adds the reader opt-in, preferred
+time, and last-sent date. Bible270 does not install a scheduler. The host application should run this
+task periodically—every 15 minutes is recommended—using its existing cron, platform scheduler, or
+recurring-job system:
+
+```bash
+bin/rails bible270:reminders:send
+```
+
+Each run converts `Time.now` through `Bible270.local_time`, waits until each reader's chosen `HH:MM`
+time, sends inline with `deliver_now`, and prints the number delivered. Set `config.time_zone` when the
+plan should not follow the server's local clock. Running periodically is safe because delivery is
+idempotent once per local date: readers already marked for that date are skipped. Undated readers,
+calendar dates before or after their plan, completed days, blank email addresses, and readers who have
+not opted in are also skipped. A failure for one reader is logged and does not stop the rest. The sent
+date is recorded only after delivery succeeds.
+
 ## Configuration reference
 
 ```ruby
@@ -326,6 +377,9 @@ Bible270.configure do |config|
   # config.start_date = Date.new(2026, 9, 6)  
   config.allow_reader_start_date = true
 
+  config.daily_reminders = false             # schedule reminders:send every 15 minutes
+  config.mailer_host = "example.com"          # links in reminder/notice email
+
   config.parent_controller = "ActionController::Base"   # or "::ApplicationController"
   config.layout            = "bible270/application"
 
@@ -397,7 +451,7 @@ The CMS serves your content; this is a separate mounted app. Either **just link
 
 | Table | Holds |
 |-------|-------|
-| `bible270_readers` | identity, avatar, provider/uid or polymorphic `owner`, start date, translation and passage-reader preferences |
+| `bible270_readers` | identity, avatar, provider/uid or polymorphic `owner`, start date, translation, passage-reader, and reminder preferences |
 | `bible270_checkoffs` | one row per reader per day per track (`ot`/`nt`/`pp`), unique-indexed |
 | `bible270_comments` | a reflection on a day, optionally scoped to a track, public to all |
 | `bible270_sign_in_tokens` | magic-link tokens: email, **digest only**, expiry, consumed-at |
@@ -471,7 +525,7 @@ All computed at load and memoized — no generated schedule, so nothing to migra
 
 ## Scaling
 
-The leaderboard counts completed days in Ruby from grouped check-offs — fine for hundreds of readers. Past a few thousand, cache a `days_completed` counter on `Reader` via a `Checkoff` `after_commit` and sort in SQL.
+Community pages count completed days in Ruby from grouped check-offs — fine for hundreds of readers. Past a few thousand, cache a `days_completed` counter on `Reader` via a `Checkoff` `after_commit` and read it directly in SQL.
 
 ## Troubleshooting
 
@@ -499,9 +553,18 @@ The engine's CSS rides in a partial its own layout renders. Using your layout? A
 
 ```bash
 bundle install
-rake test
+bundle exec rake test
+bundle exec rubocop --cache false
 ```
 
+`rake test` runs two isolated processes, streams colorized progress in real time, then prints one
+consolidated result and duration. It merges their SimpleCov results, writes a browsable report to
+`coverage/index.html`, and
+records per-file runtimes in `tmp/parallel_runtime_test.log` to improve
+subsequent balancing. Set `PARALLEL_WORKERS` to tune the worker count. Use
+`bundle exec rake test:serial` when a serial coverage run is specifically needed; it writes to the same
+project-local `coverage/` directory.
+
 ### Get an email link for local testing
 
 in the rails console: `rails c`
@@ -518,7 +581,7 @@ Bug reports and pull requests are welcome at <https://github.com/avonderluft/bib
 
 1. Fork it and clone your fork.
 2. Branch off `main`: `git checkout -b my-feature`.
-3. Make your change, and add tests — `rake test` should stay green.
+3. Make your change, and add tests — `bundle exec rake test` and `bundle exec rubocop --cache false` should stay green.
 4. Commit with a clear message: `git commit -am "Add my feature"`.
 5. Push: `git push origin my-feature`.
 6. Open a pull request against `main`, saying what changed and why.

data/Rakefile

@@ -1,7 +1,138 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks' # provides build / install / release
+require 'open3'
 require 'rake/testtask'
+require 'stringio'
+
+module Bible270TestOutput
+  SUMMARY = %r{(?<assertions>\d+) assertions, (?<errors>\d+) errors, (?<failures>\d+) failures, (?<skips>\d+) skips?, (?<tests>\d+) tests}
+  COLORS = { green: 32, yellow: 33, red: 31, cyan: 36 }.freeze
+
+  class Progress
+    def initialize(io)
+      @io = io
+      @line = +''
+      @pending = +''
+      @awaiting_blank = false
+      @expecting_progress = false
+      @printing_progress = false
+    end
+
+    def feed(chunk)
+      chunk.each_char { |character| consume(character) }
+      flush
+    end
+
+    def finish
+      flush
+      @io.puts if @printing_progress
+    end
+
+  private
+
+    def consume(character)
+      return if character == "\r"
+      return finish_line if character == "\n"
+
+      if @expecting_progress && character.match?(%r{[.EFS]})
+        @printing_progress = true
+        @pending << character
+      elsif @printing_progress
+        flush
+        @io.puts
+        @printing_progress = false
+        @expecting_progress = false
+        @line = +character
+      else
+        @expecting_progress = false if @expecting_progress
+        @line << character
+      end
+    end
+
+    def finish_line
+      flush
+      if @printing_progress
+        @io.puts
+        @expecting_progress = false
+      elsif @line.start_with?('# Running tests')
+        @awaiting_blank = true
+      elsif @awaiting_blank && @line.empty?
+        @expecting_progress = true
+        @awaiting_blank = false
+      end
+      @line.clear
+      @printing_progress = false
+    end
+
+    def flush
+      return if @pending.empty?
+
+      @io.print Bible270TestOutput.progress_color(@pending)
+      @io.flush
+      @pending.clear
+    end
+  end
+
+module_function
+
+  def capture(env, command)
+    output = +''
+    errors = +''
+    status = nil
+    started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    progress = Progress.new($stdout)
+
+    Open3.popen3(env, *command) do |stdin, stdout, stderr, wait_thread|
+      stdin.close
+      error_reader = Thread.new { stderr.read }
+      loop do
+        chunk = stdout.readpartial(4096)
+        output << chunk
+        progress.feed(chunk)
+      end
+    rescue EOFError
+      errors = error_reader.value
+      status = wait_thread.value
+    ensure
+      progress.finish
+    end
+
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+    [output, errors, status, elapsed]
+  end
+
+  def color(text, name)
+    return text unless $stdout.tty? && !ENV.key?('NO_COLOR')
+
+    "\e[#{COLORS.fetch(name)}m#{text}\e[0m"
+  end
+
+  def progress_color(text)
+    return text unless $stdout.tty? && !ENV.key?('NO_COLOR')
+
+    highlighted = text.gsub('S', "\e[33mS\e[32m")
+      .gsub(%r{[EF]}) { |character| "\e[31m#{character}\e[32m" }
+    "\e[32m#{highlighted}\e[0m"
+  end
+
+  def summary(output)
+    counts = output.match(SUMMARY)
+    raise 'Could not read the parallel test summary' unless counts
+
+    "#{counts[:tests]} tests, #{counts[:assertions]} assertions, " \
+      "#{counts[:failures]} failures, #{counts[:errors]} errors, " \
+      "#{counts[:skips]} #{counts[:skips] == '1' ? 'skip' : 'skips'}"
+  end
+
+  def quietly
+    previous = $stdout
+    $stdout = StringIO.new
+    yield
+  ensure
+    $stdout = previous
+  end
+end
 
 desc 'Normalize permissions for files included in the gem'
 task :normalize_gem_permissions do
@@ -13,10 +144,53 @@ end
 
 Rake::Task[:build].enhance([:normalize_gem_permissions])
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test' << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.warning = false
+desc 'Run tests in isolated processes (default: 2 workers)'
+namespace :test do
+  task :prepare_serial do
+    FileUtils.rm_rf('coverage')
+    ENV['TMPDIR'] = ENV.fetch('BIBLE270_TEST_TMPDIR', '/tmp')
+  end
+
+  desc 'Run tests serially with coverage'
+  Rake::TestTask.new(:serial) do |t|
+    t.libs << 'test' << 'lib'
+    t.pattern = 'test/**/*_test.rb'
+    t.warning = false
+  end
+  Rake::Task['test:serial'].enhance(['test:prepare_serial'])
+
+  task :parallel do
+    workers = ENV.fetch('PARALLEL_WORKERS', '2')
+    FileUtils.rm_rf('coverage')
+    env = {
+      'PARALLEL_COVERAGE' => 'true',
+      'RECORD_RUNTIME' => 'true',
+      'SKIP_COV' => nil,
+      'NO_COLOR' => '1',
+      'TMPDIR' => ENV.fetch('BIBLE270_TEST_TMPDIR', '/tmp')
+    }
+    command = ['bundle', 'exec', 'parallel_test', 'test', '--type', 'test', '-n', workers]
+    puts Bible270TestOutput.color("Running tests (#{workers} workers)…", :cyan)
+    stdout, stderr, status, elapsed = Bible270TestOutput.capture(env, command)
+    unless status.success?
+      $stdout.write(stdout)
+      $stderr.write(stderr)
+      raise "Parallel tests failed with status #{status.exitstatus}"
+    end
+    $stderr.write(stderr) unless stderr.empty?
+    puts Bible270TestOutput.color(Bible270TestOutput.summary(stdout), :green)
+    puts Bible270TestOutput.color(format('Completed in %.1f seconds', elapsed), :cyan)
+
+    require 'simplecov'
+    SimpleCov.coverage_dir File.expand_path('coverage', __dir__)
+    result = SimpleCov::ResultMerger.merged_result
+    Bible270TestOutput.quietly { SimpleCov::Formatter::HTMLFormatter.new.format(result) }
+    coverage = format('Coverage: %<percent>.2f%% (%<covered>d/%<total>d) — coverage/index.html',
+                      percent: result.covered_percent, covered: result.covered_lines, total: result.total_lines)
+    puts Bible270TestOutput.color(coverage, :green)
+  end
 end
 
+desc 'Run tests in parallel'
+task test: 'test:parallel'
 task default: :test

data/app/controllers/bible270/checkoffs_controller.rb

@@ -15,21 +15,46 @@ module Bible270
                                           Plan.present_tracks(@day).include?(@track) &&
                                           Plan.valid_part?(@day, @track, @part)
 
-      existing = current_reader.checkoffs.find_by(day: @day, track: @track, part: @part)
-      if existing
-        existing.destroy
-      else
-        current_reader.ensure_started!
-        current_reader.checkoffs.create(day: @day, track: @track, part: @part)
-      end
+      requested_state = params[:checked] if params.key?(:checked)
+      head :bad_request and return if params.key?(:checked) && !%w[0 1].include?(requested_state)
+
+      marked_read = apply_checkoff(requested_state)
 
-      @reader = current_reader.reload
+      @reader = current_reader.reload.reload_progress
       @reader_tracks = @reader.read_tracks_for(@day)
       @readings = Plan.readings_for(@day)
 
+      required = Plan.total_parts(@day)
+      completer_ids = Checkoff.where(day: @day)
+        .group(:reader_id)
+        .having('COUNT(*) >= ?', required)
+        .pluck(:reader_id)
+      @completers = Reader.where(id: completer_ids).order(:display_name)
+
       respond_to do |format|
         format.turbo_stream
-        format.html { redirect_to day_path(@day) }
+        format.html do
+          message = marked_read ? 'Reading marked read.' : 'Reading marked unread.'
+          redirect_to day_path(@day), flash: { b270_interaction_status: message }
+        end
+      end
+    end
+
+  private
+
+    def apply_checkoff(requested_state)
+      existing = current_reader.checkoffs.find_by(day: @day, track: @track, part: @part)
+      if requested_state == '1'
+        current_reader.ensure_started!
+        current_reader.checkoffs.create_or_find_by!(day: @day, track: @track, part: @part)
+        true
+      elsif requested_state == '0' || existing
+        existing&.destroy
+        false
+      else
+        current_reader.ensure_started!
+        current_reader.checkoffs.create(day: @day, track: @track, part: @part)
+        true
       end
     end
   end

data/app/controllers/bible270/comments_controller.rb

@@ -3,8 +3,12 @@
 module Bible270
   class CommentsController < ApplicationController
     def index
+      visited_at = Time.current
       @days_with_reflections = Comment.approved.distinct.pluck(:day).sort
-      @threads = recent_threads
+      load_reflection_filters
+      load_reflection_page
+      load_new_reflections
+      current_reader&.mark_reflections_seen!(visited_at)
     end
 
     def create
@@ -19,13 +23,18 @@ module Bible270
       if @comment.save
         respond_to do |format|
           format.turbo_stream
-          format.html { redirect_to day_path(@day, anchor: "comment-#{@comment.id}") }
+          format.html do
+            message = @comment.reply? ? 'Reply posted.' : 'Reflection posted.'
+            redirect_to day_path(@day, anchor: "comment-#{@comment.id}"),
+                        flash: { b270_interaction_status: message }
+          end
         end
       else
         respond_to do |format|
           format.turbo_stream do
             render turbo_stream: turbo_stream.replace('new_comment_form', partial: 'bible270/comments/form',
-                                                                          locals: { day: @day, comment: @comment })
+                                                                          locals: { day: @day, comment: @comment }),
+                   status: :unprocessable_entity
           end
           format.html { redirect_to day_path(@day), alert: @comment.errors.full_messages.to_sentence }
         end
@@ -42,14 +51,18 @@ module Bible270
       if @comment.update(comment_params.except(:parent_id))
         respond_to do |format|
           format.turbo_stream
-          format.html { redirect_to day_path(@day, anchor: "comment-#{@comment.id}") }
+          format.html do
+            redirect_to day_path(@day, anchor: "comment-#{@comment.id}"),
+                        flash: { b270_interaction_status: 'Changes saved.' }
+          end
         end
       else
         respond_to do |format|
           format.turbo_stream do
             render turbo_stream: turbo_stream.replace("comment-#{@comment.id}",
                                                       partial: 'bible270/comments/edit_form',
-                                                      locals: { comment: @comment })
+                                                      locals: { comment: @comment }),
+                   status: :unprocessable_entity
           end
           format.html { redirect_to day_path(@day), alert: @comment.errors.full_messages.to_sentence }
         end
@@ -72,30 +85,52 @@ module Bible270
 
   private
 
-    # The most recently active conversations, newest first. A reply counts as
-    # activity, so answering an old reflection brings the whole thread back up —
-    # otherwise a lively discussion on day 3 would stay buried while quieter, newer
-    # reflections sat above it.
-    def recent_threads
-      wanted = Bible270.config.reflections_page_size.to_i
-      wanted = 10 unless wanted.positive?
-
-      # Look at rather more messages than threads, since several may belong to one.
-      recent = Comment.approved.order(created_at: :desc).limit(wanted * 5)
-        .pluck(:id, :parent_id, :created_at)
-
-      roots = {}
-      recent.each do |id, parent_id, created_at|
-        root = parent_id || id
-        roots[root] ||= created_at
-        roots[root] = created_at if created_at > roots[root]
-      end
+    def load_reflection_filters
+      root_reflections = Comment.approved.where(parent_id: nil)
+      reader_ids = root_reflections.distinct.pluck(:reader_id)
+      @reflection_readers = Reader.where(id: reader_ids).to_a.sort_by(&:sort_name)
+
+      requested_day = params[:day].presence&.to_i
+      @reflection_day = requested_day if @days_with_reflections.include?(requested_day)
+
+      requested_reader = params[:reader_id].presence&.to_i
+      @reflection_reader_id = requested_reader if reader_ids.include?(requested_reader)
+    end
+
+    def load_reflection_page
+      result = Comment.thread_page(
+        day: @reflection_day,
+        reader_id: @reflection_reader_id,
+        page: params[:page],
+        per_page: Bible270.config.reflections_page_size
+      )
+      @threads = result.threads
+      @thread_activity = result.activity_by_id
+      @reflection_page = result.page
+      @reflection_pages = result.pages
+      @reflection_total = result.total
+    end
+
+    def load_new_reflections
+      @reflections_since = reflections_since
+      @reflections_since_param = @reflections_since&.iso8601(6) || 'none'
+      @new_thread_ids = if @reflections_since
+                          @thread_activity.filter_map do |id, activity_at|
+                            id if activity_at > @reflections_since
+                          end
+                        else
+                          []
+                        end
+    end
+
+    def reflections_since
+      return nil unless current_reader&.class&.reflections_seen_column?
+      return current_reader.reflections_seen_at unless params.key?(:since)
+      return nil if params[:since] == 'none'
 
-      ids = roots.sort_by { |_root, at| -at.to_i }.first(wanted).map(&:first)
-      threads = Comment.approved.where(id: ids)
-        .includes(:reader, { likes: :reader }, { replies: [:reader, { likes: :reader }] })
-        .index_by(&:id)
-      ids.filter_map { |id| threads[id] }
+      Time.iso8601(params[:since].to_s)
+    rescue ArgumentError
+      current_reader.reflections_seen_at
     end
 
     def comment_params

data/app/controllers/bible270/days_controller.rb

@@ -5,12 +5,26 @@ module Bible270
     def index
       @plan_totals = Plan.totals
 
-      # Community leaderboard (small-community friendly; see README on scaling).
-      @readers = Reader.order(updated_at: :desc).to_a
+      # Show recent participation without ranking readers by completion. A checkoff
+      # or reflection counts as activity; joining is the fallback for new readers.
+      @readers = Reader.all.to_a
+      checkoff_activity = Checkoff.group(:reader_id).maximum(:updated_at)
+      reflection_activity = Comment.approved.group(:reader_id).maximum(:updated_at)
+      @reader_activity = @readers.to_h do |reader|
+        candidates = [
+          { kind: :joined, at: reader.created_at },
+          { kind: :reading, at: checkoff_activity[reader.id] },
+          { kind: :reflection, at: reflection_activity[reader.id] }
+        ].select { |activity| activity[:at] }
+        [reader.id, candidates.max_by { |activity| activity[:at] }]
+      end
+      @readers.sort_by! do |reader|
+        [-@reader_activity.fetch(reader.id)[:at].to_f, reader.sort_name]
+      end
+
       counts = Checkoff.group(:reader_id, :day).count
       @days_completed = Hash.new(0)
       counts.each { |(rid, day), n| @days_completed[rid] += 1 if n >= Plan.total_parts(day) }
-      @readers = @readers.sort_by { |r| -@days_completed[r.id] }
 
       @start_day = current_reader&.current_day || 1
       # nil outside the plan's window, so no "Go to today" before it begins
@@ -41,9 +55,6 @@ module Bible270
         .having('COUNT(*) >= ?', required)
         .pluck(:reader_id)
       @completers = Reader.where(id: completer_ids).order(:display_name)
-
-      @prev_day = @day > 1 ? @day - 1 : nil
-      @next_day = @day < Plan::DAYS ? @day + 1 : nil
     end
 
   private

data/app/controllers/bible270/likes_controller.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Bible270
-  # A heart on someone's reflection. One route, because liking and unliking are
-  # the same gesture — tapping the heart again takes it back.
+  # A heart on someone's reflection. The route accepts the intended state from
+  # current forms and retains toggle behavior for cached or external callers.
   class LikesController < ApplicationController
     def toggle
       return unless require_reader!
@@ -10,12 +10,23 @@ module Bible270
       @comment = Comment.approved.find_by(id: params[:id])
       head :not_found and return unless @comment
 
-      @comment.toggle_like!(current_reader)
+      requested_state = params[:liked] if params.key?(:liked)
+      head :bad_request and return if params.key?(:liked) && !%w[0 1].include?(requested_state)
+
+      liked = if requested_state
+                @comment.set_like!(current_reader, liked: requested_state == '1')
+              else
+                @comment.toggle_like!(current_reader)
+              end
       @comment.reload
 
       respond_to do |format|
         format.turbo_stream
-        format.html { redirect_to day_path(@comment.day, anchor: "comment-#{@comment.id}") }
+        format.html do
+          message = liked ? 'Reflection liked.' : 'Like removed.'
+          redirect_to day_path(@comment.day, anchor: "comment-#{@comment.id}"),
+                      flash: { b270_interaction_status: message }
+        end
       end
     end
   end