textus 0.14.3 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65cfe5f73a64dda44280d1dd58e418aecdc94b79e1abb68340e973d364da3465
-  data.tar.gz: c35f1428a0965c11c946395a8fb7dfeb60202e2fac2514b1bb04dfae1e426ed2
+  metadata.gz: 54b9e7266b017d02abba0f6daeba977c580c07f1bdab798ebc7a9b943be555cd
+  data.tar.gz: 47ebf2a56523dbf33058fe95c45163899a6f7b91500a2f749ce3d731e60ab502
 SHA512:
-  metadata.gz: edeefd203bb0f4af807457cb96353affd3a21de846331481bb3d6e69e344fc1ea8054f8066ed278e7a7ced366704a65df00269d38b58a5b729d408477bc4f5a5
-  data.tar.gz: 4c30fa46409c381bfa8ef381c38314ce988786b9f2cf81c8b1c76f7508301587b9e5562ce1ced415f85484fe794fe3aeff5186203f733cedea34443d43a4eb57
+  metadata.gz: 76abb1c22c3f519574dfd310a7ff2162b023bbbc8667b2e4dc2c32edbb94d432bf507620116dbcbc1f7ce3328964515ee8eded62abe1c833249b3b2bb1bd9fce
+  data.tar.gz: a405b5d81159c8dd0638e9ca6f4fca419358792c7a3a29f64cb0b19386553f37aa091f913c65ad078a039205ad6ac0368af681eba455fcb4c1787bcfb213ac05

data/CHANGELOG.md

@@ -9,6 +9,113 @@ The **gem version** (`0.x.y`) is distinct from the **protocol version**
 bump is a breaking change that requires a store migration; the gem version
 tracks both additive improvements and breaking protocol bumps independently.
 
+## 0.15.0 — 2026-05-26
+
+### Breaking
+
+- `Application::Reads::Get#call` is now a **pure read**: it returns the
+  on-disk envelope annotated with a freshness verdict, and never
+  triggers refresh. `Reads::Get.new` no longer accepts `orchestrator:`.
+  Callers that relied on refresh-on-read should switch to
+  `Application::Reads::GetOrRefresh` (new), accessible via
+  `ops.reads.get_or_refresh`. The CLI verb `textus get` is migrated
+  internally; users of `textus get` see no behavior change.
+- `Application::Context#bypass_freshness?` and the `bypass_freshness:`
+  kwarg on `Context.new` / `Operations.for` are **removed**. They
+  shipped in 0.14.4 as a workaround; with `Reads::Get` now pure by
+  default, the flag is dead code. Callers passing `bypass_freshness:`
+  will see `ArgumentError`.
+- `Projection.new` signature is **breaking**: now
+  `Projection.new(reader:, spec:, lister:, transform_resolver:, transform_context:)`.
+  `Projection` no longer constructs its own `Operations` chain. Callers
+  inject collaborators. `Builder::Pipeline` is migrated internally.
+- Intake handlers now receive `args: { trigger_key:, leaf_segments: }`
+  instead of `args: {}`. Handlers that destructure `args` should
+  expect the new keys. Handlers that pass `args` through unchanged
+  are unaffected.
+
+### Fixed
+
+- **Bug 1 / single-flight.** `Refresh::Orchestrator#run_timed` now
+  probes the per-leaf lock before forking the detached refresh
+  worker. If the lock is held (by a sibling process or earlier fork),
+  the orchestrator returns `Outcome::Detached` without spawning a
+  redundant worker. Prevents wasted forks when the same key is read
+  concurrently across processes.
+- **Bug 2 / leaf-aware intake.** `Refresh::Worker` now keeps the
+  `remaining` segments from `Manifest#resolve(key)` and passes them
+  to the intake handler as `args: { trigger_key:, leaf_segments: }`.
+  Handlers can scope to one leaf instead of re-processing the full
+  parent `intake_config` for every leaf refresh.
+- **`textus refresh stale` now exits 0 on success.** Previously the
+  verb fell off the end returning `nil`, which propagated up through
+  `CLI.run` to `exe/textus:4`'s `exit nil` and raised `TypeError`,
+  exit-coding 1 on every successful refresh. Fixed by returning an
+  explicit Integer from the verb. The verb return-value contract is
+  now codified: every verb's `#call` returns Integer (or `nil` →
+  treated as 0); `CLI.run` coerces. (#61)
+
+### Added
+
+- `Application::Reads::GetOrRefresh` — explicit composition of pure
+  `Reads::Get` with the refresh orchestrator. Use for interactive
+  reads that want freshest-obtainable envelopes.
+- `ops.reads.get_or_refresh` accessor.
+
+### Migration
+
+If your code (or hook / handler / extension) called:
+
+| Old | New |
+|---|---|
+| `ops.reads.get.call(key)` to get the freshest envelope | `ops.reads.get_or_refresh.call(key)` |
+| `ops.reads.get.call(key)` for pure read | unchanged; now also pure semantics |
+| `Operations.for(store, bypass_freshness: true)` | `Operations.for(store)` |
+| `Projection.new(store, spec)` | `Projection.new(reader:, spec:, lister:, transform_resolver:, transform_context:)` — see `builder/pipeline.rb` for canonical wiring |
+| Handler signature `lambda { \|store:, config:, args:\| ... }` with `args == {}` | unchanged — `args` is now populated with `:trigger_key` and `:leaf_segments`; handlers that ignore them keep working |
+
+## 0.14.4 — 2026-05-26
+
+### Fixed
+
+- `textus build` no longer triggers per-leaf refresh fan-out when
+  projection reads encounter stale entries under `on_stale: timed_sync`
+  / `on_stale: sync`. Build is a downstream materialization step over
+  current store state; freshness is an inflow concern, and they
+  shouldn't compose. Previously, building a marketplace-style output
+  whose projection selected `intake.vendor.**` against ~400 stale
+  leaves spawned ~400 concurrent detached refresh workers, each
+  re-running the full intake handler, exhausting the system. The
+  build pipeline now reads through an `Application::Context` with
+  `bypass_freshness: true`, so `Application::Reads::Get` returns the
+  on-disk envelope annotated as fresh without consulting the
+  orchestrator. Explicit freshness before build still works via
+  `textus refresh stale`. (#59)
+
+### Added
+
+- `Application::Context#bypass_freshness?` — new flag for read paths
+  that must not initiate refresh. Threaded through `Operations.for`
+  and propagated across `Context#with_role`. Used by `Builder::Pipeline`
+  via a `bypass_freshness:` constructor kwarg on `Projection`.
+- `textus doctor` now reports stale per-key refresh lock files under
+  `<root>/.locks/` whose recorded PID is no longer running, as an
+  `info`-level `refresh_lock.stale` issue. The check is purely
+  informational: `Refresh::Lock` uses `flock(2)`, which the kernel
+  releases on process death, so stale `.lock` files on disk do not
+  block subsequent refresh acquires. The check exists so users can
+  clean up forensic clutter and notice unexpected accumulation. No
+  read-path changes — adding a PID probe + unlink there would
+  reintroduce the TOCTOU and PID-reuse hazards explicitly rejected
+  in 0.14.3 / PR #57. (#58)
+
+### Tested
+
+- Added a regression spec that forks a child, takes a per-key
+  `Refresh::Lock`, SIGKILLs the child, and asserts a fresh acquire
+  on the same key succeeds without manual cleanup. Pins the
+  flock-survives-SIGKILL contract.
+
 ## 0.14.3 — 2026-05-26
 
 ### Added

data/docs/conventions.md

@@ -105,6 +105,17 @@ textus refresh-stale --zone=intake --as=runner   # in cron / CI
 
 See [`./zones.md` §6](zones.md) for the full intake contract and [`./events.md`](events.md) for writing custom handlers.
 
+### Read vs. refresh
+
+There are two read operations, and the difference matters in custom code:
+
+| Operation | Triggers refresh? | Use for |
+|-----------|-------------------|---------|
+| `ops.reads.get` | No — pure read of on-disk envelope + freshness verdict | build / materialization paths, schema tooling, any context where a side-effecting read would surprise the caller |
+| `ops.reads.get_or_refresh` | Yes — composes `get` with the orchestrator per the rule's `on_stale` policy | interactive reads (`textus get`, dashboards) where the caller wants the freshest envelope obtainable |
+
+Build always uses the pure path; injecting refresh into materialization caused the cascading-staleness incident behind issue #59. Pick `get_or_refresh` only when you genuinely want side effects on read.
+
 ## Body content
 
 - **Bodies are Markdown.** Headings, lists, code fences — whatever a human or agent finds useful.

data/lib/textus/application/context.rb

@@ -10,12 +10,12 @@ module Textus
       end
 
       def initialize(store:, role:, correlation_id: nil, clock: Time, dry_run: false)
-        @store          = store
-        @role           = role.to_s
-        @correlation_id = correlation_id || SecureRandom.uuid
-        @clock          = clock
-        @dry_run        = dry_run
-        @now            = nil
+        @store             = store
+        @role              = role.to_s
+        @correlation_id    = correlation_id || SecureRandom.uuid
+        @clock             = clock
+        @dry_run           = dry_run
+        @now               = nil
       end
 
       def now

data/lib/textus/application/reads/get.rb

@@ -1,11 +1,15 @@
 module Textus
   module Application
     module Reads
+      # Pure read: returns the on-disk envelope annotated with a freshness
+      # verdict. Never triggers refresh; never invokes the orchestrator.
+      #
+      # For interactive reads that want refresh-on-stale, use
+      # `Reads::GetOrRefresh`, which composes this with the orchestrator.
       class Get
-        def initialize(ctx:, orchestrator:, evaluator: Textus::Domain::Freshness::Evaluator)
-          @ctx          = ctx
-          @orchestrator = orchestrator
-          @evaluator    = evaluator
+        def initialize(ctx:, evaluator: Textus::Domain::Freshness::Evaluator)
+          @ctx       = ctx
+          @evaluator = evaluator
         end
 
         def call(key)
@@ -19,37 +23,15 @@ module Textus
           policy = refresh_policy.to_freshness_policy
           verdict = @evaluator.call(policy, envelope, now: @ctx.now)
 
-          return annotate(envelope, verdict, refreshing: false) if verdict.fresh?
-
-          action = policy.decide(verdict)
-          outcome = @orchestrator.execute(action, key: key)
-
-          case outcome
-          when Textus::Domain::Outcome::Skipped
-            annotate(envelope, verdict, refreshing: false)
-          when Textus::Domain::Outcome::Refreshed
-            fresh_verdict = @evaluator.call(policy, outcome.envelope, now: @ctx.now)
-            annotate(outcome.envelope, fresh_verdict, refreshing: false)
-          when Textus::Domain::Outcome::Detached
-            annotate(envelope, verdict, refreshing: true)
-          when Textus::Domain::Outcome::Failed
-            annotate(envelope, verdict, refreshing: false, refresh_error: outcome.error.message)
-          end
+          envelope.with(freshness: {
+                          "stale" => verdict.stale?,
+                          "stale_reason" => verdict.reason,
+                          "refreshing" => false,
+                        })
         end
 
         private
 
-        def annotate(envelope, verdict, refreshing:, refresh_error: nil)
-          fresh = {
-            "stale" => verdict.stale?,
-            "stale_reason" => verdict.reason,
-            "refreshing" => refreshing,
-          }
-          fresh["refresh_error"] = refresh_error if refresh_error
-          envelope.with(freshness: fresh)
-        end
-
-        # No refresh policy applies to this key — treat as fresh, skip evaluation/orchestration.
         def annotate_fresh(envelope)
           envelope.with(freshness: { "stale" => false, "stale_reason" => nil, "refreshing" => false })
         end

data/lib/textus/application/reads/get_or_refresh.rb

@@ -0,0 +1,51 @@
+module Textus
+  module Application
+    module Reads
+      # Composes pure `Reads::Get` with the refresh orchestrator: runs Get
+      # to obtain the envelope and freshness verdict, then if the verdict
+      # is stale and the rule's `on_stale` policy demands action, hands
+      # off to the orchestrator. Use for interactive reads where the
+      # caller wants the freshest obtainable envelope.
+      #
+      # Pure reads (build, projection, schema tooling) should use
+      # `Reads::Get` directly; it has no orchestrator dependency.
+      class GetOrRefresh
+        def initialize(ctx:, get:, orchestrator:)
+          @ctx          = ctx
+          @get          = get
+          @orchestrator = orchestrator
+        end
+
+        def call(key)
+          envelope = @get.call(key)
+          return nil if envelope.nil?
+          return envelope unless envelope.freshness["stale"]
+
+          policy_set = @ctx.store.manifest.rules_for(key)
+          refresh_policy = policy_set.refresh
+          return envelope if refresh_policy.nil?
+
+          policy = refresh_policy.to_freshness_policy
+          verdict = Textus::Domain::Freshness::Verdict.stale(envelope.freshness["stale_reason"])
+          action = policy.decide(verdict)
+          outcome = @orchestrator.execute(action, key: key)
+
+          case outcome
+          when Textus::Domain::Outcome::Skipped
+            envelope
+          when Textus::Domain::Outcome::Refreshed
+            outcome.envelope.with(
+              freshness: { "stale" => false, "stale_reason" => nil, "refreshing" => false },
+            )
+          when Textus::Domain::Outcome::Detached
+            envelope.with(freshness: envelope.freshness.merge("refreshing" => true))
+          when Textus::Domain::Outcome::Failed
+            envelope.with(
+              freshness: envelope.freshness.merge("refresh_error" => outcome.error.message),
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/textus/application/refresh/orchestrator.rb

@@ -47,6 +47,15 @@ module Textus
 
           if thread.alive?
             thread.kill
+
+            # Single-flight: if a sibling process / earlier fork holds the
+            # per-leaf lock, don't fork another worker — they're already
+            # doing this work.
+            probe = Textus::Infra::Refresh::Lock.new(root: @store_root, key: key)
+            return Textus::Domain::Outcome::Detached.new unless probe.try_acquire
+
+            probe.release
+
             store_view = @store ? Textus::Application::Context.new(store: @store, role: @role) : nil
             payload = { key: key, started_at: Time.now.utc.iso8601, budget_ms: budget_ms }
             payload[:store] = store_view if store_view

data/lib/textus/application/refresh/worker.rb

@@ -12,11 +12,11 @@ module Textus
         end
 
         def run(key)
-          mentry, path, = @ctx.store.manifest.resolve(key)
+          mentry, path, remaining = @ctx.store.manifest.resolve(key)
           raise UsageError.new("no intake declared for '#{key}'") unless mentry.intake_handler
 
           before_etag = File.exist?(path) ? Etag.for_file(path) : nil
-          result = fetch_with_bus(key, mentry)
+          result = fetch_with_bus(key, mentry, remaining)
           persist_and_notify(key, mentry, result, before_etag)
         end
 
@@ -31,17 +31,21 @@ module Textus
           rule&.refresh&.fetch_timeout_seconds || FETCH_TIMEOUT_SECONDS
         end
 
-        def fetch_with_bus(key, mentry)
+        def fetch_with_bus(key, mentry, remaining)
           callable = @ctx.store.registry.rpc_callable(:resolve_intake, mentry.intake_handler)
           @bus.publish(:refresh_started, store: read_view, key: key, mode: :sync,
                                          correlation_id: @ctx.correlation_id)
-          call_intake(key, mentry, callable)
+          call_intake(key, mentry, callable, remaining)
         end
 
-        def call_intake(key, mentry, callable)
+        def call_intake(key, mentry, callable, remaining)
           timeout = fetch_timeout_for(key)
           Timeout.timeout(timeout) do
-            callable.call(store: @ctx, config: mentry.intake_config, args: {})
+            callable.call(
+              store: @ctx,
+              config: mentry.intake_config,
+              args: { trigger_key: key, leaf_segments: remaining || [] },
+            )
           end
         rescue Timeout::Error
           @bus.publish(:refresh_failed, store: read_view, key: key, error_class: "Timeout::Error",

data/lib/textus/builder/pipeline.rb

@@ -62,7 +62,14 @@ module Textus
         # 1. Load sources + project + reduce
         data =
           if mentry.projection
-            Projection.new(store, mentry.projection).run
+            ops = Operations.for(store)
+            Projection.new(
+              reader: ops.reads.get.method(:call),
+              spec: mentry.projection,
+              lister: ops.reads.list.method(:call),
+              transform_resolver: ->(name) { store.registry.rpc_callable(:transform_rows, name) },
+              transform_context: Application::Context.system(store),
+            ).run
           else
             { "entries" => [], "count" => 0, "generated_at" => Time.now.utc.iso8601 }
           end

data/lib/textus/cli/verb/get.rb

@@ -6,7 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("get requires a key")
-          result = operations_for(store).reads.get.call(key)
+          result = operations_for(store).reads.get_or_refresh.call(key)
           raise Textus::UnknownKey.new(key, suggestions: store.manifest.suggestions_for(key)) if result.nil?
 
           emit(result.to_h_for_wire)

data/lib/textus/cli/verb/refresh_stale.rb

@@ -10,7 +10,7 @@ module Textus
           ctx = context_for(store)
           result = Textus::Application::Refresh::All.call(ctx, prefix: prefix, zone: zone)
           emit(result)
-          exit(1) unless result["ok"]
+          result["ok"] ? 0 : 1
         end
       end
     end

data/lib/textus/cli.rb

@@ -47,21 +47,35 @@ module Textus
       verb = argv.shift
       raise UsageError.new("missing verb") if verb.nil?
 
-      case verb
-      when "--version", "-v" then @stdout.puts(VERSION)
-                                  0
-      when "--help", "-h"    then print_help
-                                  0
-      else
-        klass = VERBS[verb] or raise UsageError.new("unknown verb: #{verb}")
-        dispatch(klass, argv)
-      end
+      result =
+        case verb
+        when "--version", "-v" then @stdout.puts(VERSION)
+                                    0
+        when "--help", "-h"    then print_help
+                                    0
+        else
+          klass = VERBS[verb] or raise UsageError.new("unknown verb: #{verb}")
+          dispatch(klass, argv)
+        end
+
+      coerce_exit_code(result)
     rescue Textus::Error => e
       emit_error(e)
     end
 
     private
 
+    def coerce_exit_code(value)
+      case value
+      when Integer then value
+      when true, nil then 0
+      when false then 1
+      else
+        @stderr.puts("warning: verb returned non-Integer #{value.class}; treating as 0")
+        0
+      end
+    end
+
     def store
       @store ||= Store.discover(@cwd, root: @root_arg)
     end

data/lib/textus/doctor/check/refresh_locks.rb

@@ -0,0 +1,49 @@
+module Textus
+  module Doctor
+    class Check
+      # Lists per-key refresh lock files under <store.root>/.locks/ whose
+      # recorded PID is no longer running. These are forensic artifacts only:
+      # Refresh::Lock uses flock(2), which the kernel releases on process
+      # death, so stale files do not block subsequent acquires. The check
+      # exists to let users clean up clutter and notice unexpected accumulation
+      # (e.g. a refresh path that crashes repeatedly).
+      class RefreshLocks < Check
+        def call
+          dir = File.join(store.root, ".locks")
+          return [] unless File.directory?(dir)
+
+          Dir.glob(File.join(dir, "*.lock")).filter_map { |path| inspect_lock(path) }
+        end
+
+        private
+
+        def inspect_lock(path)
+          pid = File.read(path).strip.to_i
+          return nil if pid.zero?
+          return nil if pid_alive?(pid)
+
+          {
+            "code" => "refresh_lock.stale",
+            "level" => "info",
+            "subject" => path,
+            "message" => "refresh lock file at #{path} records dead PID #{pid} " \
+                         "(does not block refresh; flock is kernel-released on exit)",
+            "fix" => "safe to delete: rm #{path}",
+          }
+        rescue Errno::ENOENT
+          nil
+        end
+
+        def pid_alive?(pid)
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH
+          false
+        rescue Errno::EPERM
+          # Process exists but owned by another user — treat as alive.
+          true
+        end
+      end
+    end
+  end
+end

data/lib/textus/doctor.rb

@@ -23,6 +23,7 @@ module Textus
       Check::SchemaViolations,
       Check::RuleAmbiguity,
       Check::HandlerAllowlist,
+      Check::RefreshLocks,
     ].freeze
 
     ALL_CHECKS = CHECKS.map(&:name_key).freeze

data/lib/textus/operations/reads.rb

@@ -1,12 +1,29 @@
 module Textus
   class Operations
     class Reads
+      # `get`              — pure read; returns envelope + freshness verdict;
+      #                      never triggers refresh; no orchestrator dependency.
+      # `get_or_refresh`   — composes `get` with the refresh orchestrator; runs
+      #                      refresh per policy when the verdict says stale.
+      #                      Use this for interactive reads where the caller
+      #                      wants the freshest envelope obtainable.
+      #
+      # Pick `get` for materialization paths (build, projection, schema tooling).
+      # Pick `get_or_refresh` for interactive `textus get` and equivalent.
       def initialize(ctx)
         @ctx = ctx
       end
 
       def get
-        Application::Reads::Get.new(ctx: @ctx, orchestrator: orchestrator)
+        Application::Reads::Get.new(ctx: @ctx)
+      end
+
+      def get_or_refresh # rubocop:disable Naming/AccessorMethodName
+        Application::Reads::GetOrRefresh.new(
+          ctx: @ctx,
+          get: get,
+          orchestrator: orchestrator,
+        )
       end
 
       def freshness      = Application::Reads::Freshness.new(ctx: @ctx)

data/lib/textus/operations.rb

@@ -4,7 +4,8 @@ module Textus
   #
   #   ops = Textus::Operations.for(store, role: "agent")
   #   ops.writes.put.call(key, body: "...")
-  #   ops.reads.get.call(key)
+  #   ops.reads.get.call(key)               # pure read
+  #   ops.reads.get_or_refresh.call(key)    # read + refresh-on-stale
   #   ops.refresh.worker.call(key)
   #
   # Replaces the prior `Textus::Composition` module (deleted in v0.12.2).

data/lib/textus/projection.rb

@@ -6,9 +6,18 @@ module Textus
     MAX_LIMIT = 1000
     REDUCER_TIMEOUT_SECONDS = 2
 
-    def initialize(store, spec)
-      @store = store
-      @spec = spec || {}
+    # `reader` — a callable `->(key) { envelope_or_nil }`. Caller picks
+    #   semantics: pure read (`ops.reads.get`) for materialization paths;
+    #   `ops.reads.get_or_refresh` if you want refresh-on-stale.
+    # `lister` — a callable `->(prefix:) { [ { "key" => ... }, ... ] }`.
+    # `transform_resolver` — a callable `->(name) { callable_or_raise }`.
+    # `transform_context` — `Application::Context` handed to the transform reducer.
+    def initialize(reader:, spec:, lister:, transform_resolver:, transform_context:)
+      @reader             = reader
+      @spec               = spec || {}
+      @lister             = lister
+      @transform_resolver = transform_resolver
+      @transform_context  = transform_context
       @limit = (@spec["limit"] || MAX_LIMIT).to_i
       raise InvalidProjection.new("limit #{@limit} exceeds max #{MAX_LIMIT}") if @limit > MAX_LIMIT
     end
@@ -17,7 +26,7 @@ module Textus
       keys = collect_keys
       explicit_pluck = !@spec["pluck"].nil? && @spec["pluck"] != "*"
       rows = keys.map do |key|
-        env = Operations.for(@store).reads.get.call(key)
+        env = @reader.call(key)
         row = pluck(env.meta, env.body)
         explicit_pluck ? row : row.merge("_key" => key)
       end
@@ -39,10 +48,9 @@ module Textus
 
     def apply_reducer(rows)
       name = @spec["transform"] or return rows
-      callable = @store.registry.rpc_callable(:transform_rows, name)
-      view = Application::Context.system(@store)
+      callable = @transform_resolver.call(name)
       Timeout.timeout(REDUCER_TIMEOUT_SECONDS) do
-        callable.call(store: view, rows: rows, config: @spec["transform_config"] || {})
+        callable.call(store: @transform_context, rows: rows, config: @spec["transform_config"] || {})
       end
     rescue Timeout::Error
       raise UsageError.new("transform_rows '#{name}' exceeded #{REDUCER_TIMEOUT_SECONDS}s timeout")
@@ -50,8 +58,7 @@ module Textus
 
     def collect_keys
       prefixes = Array(@spec["select"])
-      ops = Operations.for(@store)
-      prefixes.flat_map { |p| ops.reads.list.call(prefix: p).map { |row| row["key"] } }.uniq
+      prefixes.flat_map { |p| @lister.call(prefix: p).map { |row| row["key"] } }.uniq
     end
 
     def pluck(frontmatter, _body)

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.14.3"
+  VERSION = "0.15.0"
   PROTOCOL = "textus/3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.14.3
+  version: 0.15.0
 platform: ruby
 authors:
 - Patrick
@@ -115,6 +115,7 @@ files:
 - lib/textus/application/reads/deps.rb
 - lib/textus/application/reads/freshness.rb
 - lib/textus/application/reads/get.rb
+- lib/textus/application/reads/get_or_refresh.rb
 - lib/textus/application/reads/list.rb
 - lib/textus/application/reads/policy_explain.rb
 - lib/textus/application/reads/published.rb
@@ -188,6 +189,7 @@ files:
 - lib/textus/doctor/check/intake_registration.rb
 - lib/textus/doctor/check/manifest_files.rb
 - lib/textus/doctor/check/protocol_version.rb
+- lib/textus/doctor/check/refresh_locks.rb
 - lib/textus/doctor/check/rule_ambiguity.rb
 - lib/textus/doctor/check/schema_parse_error.rb
 - lib/textus/doctor/check/schema_violations.rb