textus 0.47.1 → 0.49.0

data/lib/textus/read/get.rb

@@ -2,42 +2,39 @@ module Textus
   module Read
     # The one read path. `fetch:` controls behavior:
     #   fetch: false (default) — pure read: the on-disk envelope annotated with
-    #     a freshness verdict. NEVER builds the orchestrator (no threads/forks/
-    #     locks/events). This is the safe default for direct (in-process)
-    #     callers — accept/reject/publish, materializer, uid, validate_all/
-    #     validator, schema tooling, and the hook context — that must read
-    #     persisted truth without triggering a fetch.
-    #   fetch: true — read-through: after a stale verdict, hands off to the
-    #     fetch orchestrator per the entry's fetch rule (degrades to the pure
-    #     result when the key has no rule).
+    #     a lifecycle freshness verdict. NEVER builds the orchestrator and NEVER
+    #     mutates. Safe for direct callers (accept/reject/publish, materializer,
+    #     uid, validators, hooks).
+    #   fetch: true — read-through: after a stale verdict on a `refresh` policy,
+    #     hands off to the fetch orchestrator. A read NEVER performs a
+    #     destructive action (drop/archive) — those belong to the `tend` sweep
+    #     (ADR 0079).
     #
-    # The public `get` verb is read-through because the contract declares
-    # `arg :fetch, default: true`, injected on every verb surface (RoleScope +
-    # MCP map_args, ADR 0062 amendment). Direct construction bypasses that
-    # injection and so gets the safe `fetch: false` method default.
+    # Lifecycle policy comes from the unified `lifecycle:` rule slot (ADR 0079).
     class Get
       extend Textus::Contract::DSL
 
       verb     :get
-      summary  "Read one entry. Read-through by default — fetches on stale per " \
-               "the entry's fetch rule, degrading to a pure read when the key " \
-               "has no rule. Pass fetch:false for a guaranteed pure on-disk " \
-               "read. Returns the envelope (uid, etag, _meta, body, freshness)."
+      summary  "Read one entry. Read-through by default — refreshes on stale per " \
+               "the entry's lifecycle rule (on_expire: refresh), degrading to a " \
+               "pure read when the key has no rule. Pass fetch:false for a " \
+               "guaranteed pure on-disk read. Returns the envelope (uid, etag, " \
+               "_meta, body, freshness)."
       surfaces :cli, :mcp
       arg :key, String, required: true, positional: true,
                         description: "dotted entry key to read, e.g. 'knowledge.project'"
       arg :fetch, :boolean, default: true,
-                            description: "read-through (fetch on stale per the " \
-                                         "entry's fetch rule) when true, the default; " \
+                            description: "read-through (refresh on stale per the " \
+                                         "entry's lifecycle rule) when true, the default; " \
                                          "false returns the on-disk envelope without ever fetching"
       view { |v, _i| v.to_h_for_wire }
 
-      def initialize(container:, call:, evaluator: Textus::Domain::Freshness::Evaluator, orchestrator: nil)
+      def initialize(container:, call:, orchestrator: nil, file_stat: Textus::Ports::Storage::FileStat.new)
         @container  = container
         @call       = call
         @manifest   = container.manifest
         @file_store = container.file_store
-        @evaluator  = evaluator
+        @file_stat  = file_stat
         @orchestrator = orchestrator # nil → built lazily on first fetch only
       end
 
@@ -46,12 +43,11 @@ module Textus
         return envelope if envelope.nil?
         return envelope unless fetch && envelope.freshness&.stale
 
-        fetch_policy = fetch_policy_for(key)
-        return envelope if fetch_policy.nil?
+        policy = lifecycle_for(key)
+        return envelope unless policy&.on_expire == :refresh # only refresh acts on a read
 
-        policy  = fetch_policy.to_freshness_policy
         verdict = Textus::Domain::Freshness::Verdict.stale(envelope.freshness.reason)
-        outcome = orchestrator.execute(policy.decide(verdict), key: key)
+        outcome = orchestrator.execute(refresh_policy(policy).decide(verdict), key: key)
         resolve(outcome, envelope)
       end
 
@@ -64,23 +60,42 @@ module Textus
 
       private
 
-      # Pure read + freshness verdict; no orchestrator dependency.
+      # Pure read + unified lifecycle verdict; no orchestrator dependency.
       def annotated_envelope(key)
         envelope = read_raw_envelope(key)
         return nil if envelope.nil?
 
-        fetch_policy = fetch_policy_for(key)
-        return annotate_fresh(envelope) if fetch_policy.nil?
+        policy = lifecycle_for(key)
+        return annotate_fresh(envelope) if policy.nil?
 
-        policy  = fetch_policy.to_freshness_policy
-        verdict = @evaluator.call(policy, envelope, now: @call.now)
+        expired, reason = Textus::Domain::Lifecycle.verdict(
+          policy: policy,
+          last_fetched_at: envelope.meta&.dig("last_fetched_at"),
+          mtime: mtime_for(key),
+          now: @call.now,
+        )
         envelope.with(freshness: Textus::Domain::Freshness.build(
-          stale: verdict.stale?, reason: verdict.reason, fetching: false,
+          stale: expired, reason: reason, fetching: false,
         ))
       end
 
-      def fetch_policy_for(key)
-        @manifest.rules.for(key).fetch
+      def lifecycle_for(key)
+        @manifest.rules.for(key).lifecycle
+      end
+
+      def refresh_policy(policy)
+        Textus::Domain::Freshness::Policy.new(
+          ttl_seconds: policy.ttl_seconds,
+          on_stale: policy.budget_ms ? :timed_sync : :sync,
+          sync_budget_ms: policy.budget_ms,
+        )
+      end
+
+      def mtime_for(key)
+        path = @manifest.resolver.resolve(key).path
+        @file_stat.exists?(path) ? @file_stat.mtime(path) : nil
+      rescue Textus::Error
+        nil
       end
 
       def resolve(outcome, envelope)

data/lib/textus/read/pulse.rb

@@ -30,7 +30,7 @@ module Textus
         {
           "cursor" => @audit_log.latest_seq,
           "changed" => audit_changes_since(since),
-          "stale" => freshness_rows.select { |r| r[:status] == :stale }.map { |r| r[:key] },
+          "stale" => freshness_rows.select { |r| r[:status] == :expired }.map { |r| r[:key] },
           "pending_review" => review_keys,
           "doctor" => doctor_summary,
           "contract_etag" => contract_etag,

data/lib/textus/read/rule_explain.rb

@@ -1,7 +1,7 @@
 module Textus
   module Read
     # Effective rules for a key, at two depths (ADR 0059). Lean by default —
-    # `{ fetch, guard }`, the agent-cheap read that was the `rules` verb. With
+    # `{ lifecycle, guard }`, the agent-cheap read that was the `rules` verb. With
     # `detail: true` it returns the verbose explanation — every matching policy
     # block plus the per-transition guard predicate names — that was
     # `policy_explain`. One verb, one name across CLI/MCP/method; the audience
@@ -10,7 +10,7 @@ module Textus
       extend Textus::Contract::DSL
 
       verb     :rule_explain
-      summary  "Effective rules for a key. Lean {fetch, guard} by default; detail: true adds matched blocks + guard predicates."
+      summary  "Effective rules for a key. Lean {lifecycle, guard} by default; detail: true adds matched blocks + guard predicates."
       surfaces :cli, :mcp
       cli      "rule explain"
       arg :key,    String, required: true, positional: true,
@@ -34,11 +34,10 @@ module Textus
       def effective(key)
         set = @manifest.rules.for(key)
         {
-          "fetch" => set.fetch && {
-            "ttl_seconds" => set.fetch.ttl_seconds,
-            "on_stale" => set.fetch.on_stale,
-            "sync_budget_ms" => set.fetch.sync_budget_ms,
-            "fetch_timeout_seconds" => set.fetch.fetch_timeout_seconds,
+          "lifecycle" => set.lifecycle && {
+            "ttl_seconds" => set.lifecycle.ttl_seconds,
+            "on_expire" => set.lifecycle.on_expire,
+            "budget_ms" => set.lifecycle.budget_ms,
           },
           "guard" => set.guard,
         }.compact
@@ -57,22 +56,17 @@ module Textus
           matched_blocks: matching.map do |b|
             {
               match: b.match,
-              fetch: !b.fetch.nil?,
+              lifecycle: !b.lifecycle.nil?,
               handler_allowlist: !b.handler_allowlist.nil?,
               guard: !b.guard.nil?,
-              retention: !b.retention.nil?,
             }
           end,
           effective: {
-            fetch: winners.fetch && {
-              ttl_seconds: winners.fetch.ttl_seconds,
-              on_stale: winners.fetch.on_stale,
+            lifecycle: winners.lifecycle && {
+              ttl_seconds: winners.lifecycle.ttl_seconds,
+              on_expire: winners.lifecycle.on_expire,
             },
             handler_allowlist: winners.handler_allowlist&.handlers,
-            retention: winners.retention && {
-              expire_after: winners.retention.expire_after,
-              archive_after: winners.retention.archive_after,
-            },
           },
           guards: Textus::Domain::Policy::BaseGuards::BASE.keys.to_h do |transition|
             [transition, factory.for(transition, key).predicates.map(&:name)]

data/lib/textus/read/rule_list.rb

@@ -20,17 +20,15 @@ module Textus
       def call
         @manifest.rules.blocks.map do |b|
           row = { "match" => b.match }
-          if b.fetch
-            row["fetch"] = {
-              "ttl_seconds" => b.fetch.ttl_seconds,
-              "on_stale" => b.fetch.on_stale,
-              "sync_budget_ms" => b.fetch.sync_budget_ms,
-              "fetch_timeout_seconds" => b.fetch.fetch_timeout_seconds,
+          if b.lifecycle
+            row["lifecycle"] = {
+              "ttl_seconds" => b.lifecycle.ttl_seconds,
+              "on_expire" => b.lifecycle.on_expire,
+              "budget_ms" => b.lifecycle.budget_ms,
             }
           end
           row["handler_allowlist"] = b.handler_allowlist.handlers if b.handler_allowlist
           row["guard"] = b.guard if b.guard
-          row["retention"] = { "expire_after" => b.retention.expire_after, "archive_after" => b.retention.archive_after } if b.retention
           row
         end
       end

data/lib/textus/version.rb

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

data/lib/textus/write/accept.rb

@@ -52,7 +52,7 @@ module Textus
 
       def hook_context = @hook_context ||= Textus::Hooks::Context.for(container: @container, call: @call)
       def put_op       = @put_op ||= Textus::Write::Put.new(container: @container, call: @call)
-      def delete_op    = @delete_op ||= Textus::Write::Delete.new(container: @container, call: @call)
+      def delete_op    = @delete_op ||= Textus::Write::KeyDelete.new(container: @container, call: @call)
     end
   end
 end

data/lib/textus/write/fetch_worker.rb

@@ -2,16 +2,10 @@ require "timeout"
 
 module Textus
   module Write
+    # Internal fetch executor for one quarantine/intake entry. No longer a
+    # public verb (ADR 0079 collapsed the `fetch` surface): used by `get`'s
+    # orchestrator (read-through refresh) and by the `tend` sweep.
     class FetchWorker
-      extend Textus::Contract::DSL
-
-      verb     :fetch
-      summary  "Run a fetch action for one quarantine entry."
-      surfaces :cli, :mcp
-      arg :key, String, required: true, positional: true,
-                        description: "quarantine-zone entry key to refresh using its declared intake action"
-      view { |outcome| { "outcome" => outcome.class.name.split("::").last.downcase } }
-
       FETCH_TIMEOUT_SECONDS = IntakeFetch::FETCH_TIMEOUT_SECONDS
 
       def initialize(container:, call:)
@@ -69,9 +63,11 @@ module Textus
         @fetch_events ||= FetchEvents.from(container: @container, call: @call)
       end
 
-      def fetch_timeout_for(key)
-        rule = @manifest.rules.for(key)
-        rule&.fetch&.fetch_timeout_seconds || FETCH_TIMEOUT_SECONDS
+      # ADR 0079: a per-rule fetch_timeout_seconds override was an accepted loss
+      # in the fetch:/retention: → lifecycle: collapse; the constant ceiling
+      # applies to every intake.
+      def fetch_timeout_for(_key)
+        FETCH_TIMEOUT_SECONDS
       end
 
       def fetch_with_events(key, mentry, remaining)

data/lib/textus/write/{delete.rb → key_delete.rb}

@@ -1,9 +1,9 @@
 module Textus
   module Write
-    class Delete
+    class KeyDelete
       extend Textus::Contract::DSL
 
-      verb     :delete
+      verb     :key_delete
       summary  "Delete one entry by key. Single-key, lower blast radius than " \
                "key_delete_prefix; guarded by an optional optimistic-concurrency etag. Returns {ok, key, deleted}."
       surfaces :cli, :mcp
@@ -25,7 +25,7 @@ module Textus
         Textus::Manifest::Data.validate_key!(key)
         mentry = @manifest.resolver.resolve(key).entry
 
-        guard_for(:delete, key, if_etag: if_etag).check!(eval_for(:delete, target_key: key))
+        guard_for(:key_delete, key, if_etag: if_etag).check!(eval_for(:key_delete, target_key: key))
 
         writer.delete(key, mentry: mentry, if_etag: if_etag)
 

data/lib/textus/write/{mv.rb → key_mv.rb}

@@ -1,9 +1,9 @@
 module Textus
   module Write
-    class Mv
+    class KeyMv
       extend Textus::Contract::DSL
 
-      verb     :mv
+      verb     :key_mv
       summary  "Rename one entry (same zone + format). Refuses if the target exists. Single-key, lower blast radius than key_mv_prefix."
       surfaces :cli, :mcp
       cli      "key mv"
@@ -53,8 +53,8 @@ module Textus
         raise UnknownKey.new(old_key) unless reader.exists?(old_key)
 
         validate_zone_and_format!(old_res.entry, new_res.entry)
-        guard_for(:mv, old_key).check!(eval_for(:mv, target_key: old_key))
-        guard_for(:mv, new_key).check!(eval_for(:mv, target_key: new_key))
+        guard_for(:key_mv, old_key).check!(eval_for(:key_mv, target_key: old_key))
+        guard_for(:key_mv, new_key).check!(eval_for(:key_mv, target_key: new_key))
         raise UsageError.new("mv: target '#{new_key}' already exists at #{new_res.path}") if reader.exists?(new_key)
 
         [old_res, new_res]

data/lib/textus/write/reject.rb

@@ -59,7 +59,7 @@ module Textus
       end
 
       def delete_op
-        @delete_op ||= Textus::Write::Delete.new(
+        @delete_op ||= Textus::Write::KeyDelete.new(
           container: @container, call: @call,
         )
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.47.1
+  version: 0.49.0
 platform: ruby
 authors:
 - Patrick
@@ -120,7 +120,6 @@ files:
 - lib/textus/call.rb
 - lib/textus/cli.rb
 - lib/textus/cli/group.rb
-- lib/textus/cli/group/fetch.rb
 - lib/textus/cli/group/hook.rb
 - lib/textus/cli/group/key.rb
 - lib/textus/cli/group/mcp.rb
@@ -132,8 +131,6 @@ files:
 - lib/textus/cli/verb/boot.rb
 - lib/textus/cli/verb/build.rb
 - lib/textus/cli/verb/doctor.rb
-- lib/textus/cli/verb/fetch.rb
-- lib/textus/cli/verb/fetch_all.rb
 - lib/textus/cli/verb/get.rb
 - lib/textus/cli/verb/hook_run.rb
 - lib/textus/cli/verb/hooks.rb
@@ -157,10 +154,12 @@ files:
 - lib/textus/doctor/check.rb
 - lib/textus/doctor/check/audit_log.rb
 - lib/textus/doctor/check/fetch_locks.rb
+- lib/textus/doctor/check/generator_drift.rb
 - lib/textus/doctor/check/handler_allowlist.rb
 - lib/textus/doctor/check/hooks.rb
 - lib/textus/doctor/check/illegal_keys.rb
 - lib/textus/doctor/check/intake_registration.rb
+- lib/textus/doctor/check/lifecycle_action_invalid.rb
 - lib/textus/doctor/check/manifest_files.rb
 - lib/textus/doctor/check/orphaned_publish_targets.rb
 - lib/textus/doctor/check/proposal_targets.rb
@@ -179,14 +178,15 @@ files:
 - lib/textus/domain/freshness/evaluator.rb
 - lib/textus/domain/freshness/policy.rb
 - lib/textus/domain/freshness/verdict.rb
+- lib/textus/domain/lifecycle.rb
 - lib/textus/domain/outcome.rb
 - lib/textus/domain/permission.rb
 - lib/textus/domain/policy/base_guards.rb
 - lib/textus/domain/policy/evaluation.rb
-- lib/textus/domain/policy/fetch.rb
 - lib/textus/domain/policy/guard.rb
 - lib/textus/domain/policy/guard_factory.rb
 - lib/textus/domain/policy/handler_allowlist.rb
+- lib/textus/domain/policy/lifecycle.rb
 - lib/textus/domain/policy/matcher.rb
 - lib/textus/domain/policy/predicates/author_held.rb
 - lib/textus/domain/policy/predicates/etag_match.rb
@@ -195,12 +195,9 @@ files:
 - lib/textus/domain/policy/predicates/schema_valid.rb
 - lib/textus/domain/policy/predicates/target_is_canon.rb
 - lib/textus/domain/policy/predicates/zone_writable_by.rb
-- lib/textus/domain/policy/retention.rb
-- lib/textus/domain/retention.rb
 - lib/textus/domain/sentinel.rb
 - lib/textus/domain/staleness.rb
 - lib/textus/domain/staleness/generator_check.rb
-- lib/textus/domain/staleness/intake_check.rb
 - lib/textus/entry.rb
 - lib/textus/entry/base.rb
 - lib/textus/entry/json.rb
@@ -231,8 +228,8 @@ files:
 - lib/textus/maintenance.rb
 - lib/textus/maintenance/key_delete_prefix.rb
 - lib/textus/maintenance/key_mv_prefix.rb
-- lib/textus/maintenance/migrate.rb
 - lib/textus/maintenance/rule_lint.rb
+- lib/textus/maintenance/tend.rb
 - lib/textus/maintenance/zone_mv.rb
 - lib/textus/manifest.rb
 - lib/textus/manifest/capabilities.rb
@@ -293,11 +290,9 @@ files:
 - lib/textus/read/published.rb
 - lib/textus/read/pulse.rb
 - lib/textus/read/rdeps.rb
-- lib/textus/read/retainable.rb
 - lib/textus/read/rule_explain.rb
 - lib/textus/read/rule_list.rb
 - lib/textus/read/schema_envelope.rb
-- lib/textus/read/stale.rb
 - lib/textus/read/uid.rb
 - lib/textus/read/validate_all.rb
 - lib/textus/read/validator.rb
@@ -313,18 +308,16 @@ files:
 - lib/textus/version.rb
 - lib/textus/write/accept.rb
 - lib/textus/write/build.rb
-- lib/textus/write/delete.rb
-- lib/textus/write/fetch_all.rb
 - lib/textus/write/fetch_events.rb
 - lib/textus/write/fetch_orchestrator.rb
 - lib/textus/write/fetch_worker.rb
 - lib/textus/write/intake_fetch.rb
+- lib/textus/write/key_delete.rb
+- lib/textus/write/key_mv.rb
 - lib/textus/write/materializer.rb
-- lib/textus/write/mv.rb
 - lib/textus/write/propose.rb
 - lib/textus/write/put.rb
 - lib/textus/write/reject.rb
-- lib/textus/write/retention_sweep.rb
 homepage: https://github.com/patrick204nqh/textus
 licenses:
 - MIT

data/lib/textus/cli/group/fetch.rb

@@ -1,20 +0,0 @@
-module Textus
-  class CLI
-    class Group
-      class Fetch < Group
-        command_name "fetch"
-
-        def parse(argv)
-          if argv.first == "all"
-            argv.shift
-            @sub_klass = Verb::FetchAll
-          else
-            @sub_klass = Verb::Fetch
-          end
-          @sub = @sub_klass.new(stdin: @stdin, stdout: @stdout, stderr: @stderr, cwd: @cwd)
-          @sub.parse(argv)
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Textus
-  class CLI
-    class Verb
-      class Fetch < Verb
-        option :as_flag, "--as=ROLE"
-
-        def call(store)
-          key = positional.shift or raise UsageError.new("fetch requires a key")
-          emit(session_for(store).fetch(key).to_h_for_wire)
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Textus
-  class CLI
-    class Verb
-      class FetchAll < Verb
-        command_name "all"
-        parent_group Group::Fetch
-
-        option :prefix, "--prefix=KEY"
-        option :zone, "--zone=Z"
-        option :as_flag, "--as=ROLE"
-
-        def call(store)
-          result = session_for(store).fetch_all(prefix: prefix, zone: zone)
-          emit(result)
-          result["ok"] ? 0 : 1
-        end
-      end
-    end
-  end
-end

data/lib/textus/domain/policy/fetch.rb

@@ -1,37 +0,0 @@
-module Textus
-  module Domain
-    module Policy
-      class Fetch
-        ALLOWED_ON_STALE = %i[warn sync timed_sync].freeze
-
-        attr_reader :ttl, :on_stale, :sync_budget_ms, :fetch_timeout_seconds
-
-        def initialize(ttl:, on_stale:, sync_budget_ms:, fetch_timeout_seconds: nil)
-          on_stale_sym = on_stale.is_a?(Symbol) ? on_stale : on_stale.to_s.to_sym
-          unless ALLOWED_ON_STALE.include?(on_stale_sym)
-            raise Textus::UsageError.new(
-              "on_stale must be one of #{ALLOWED_ON_STALE.join(", ")} (got #{on_stale.inspect})",
-            )
-          end
-
-          @ttl                   = ttl
-          @on_stale              = on_stale_sym
-          @sync_budget_ms        = sync_budget_ms
-          @fetch_timeout_seconds = fetch_timeout_seconds
-        end
-
-        def ttl_seconds
-          Textus::Domain::Duration.seconds(@ttl)
-        end
-
-        def to_freshness_policy
-          Textus::Domain::Freshness::Policy.new(
-            ttl_seconds: ttl_seconds,
-            on_stale: @on_stale,
-            sync_budget_ms: @sync_budget_ms,
-          )
-        end
-      end
-    end
-  end
-end

data/lib/textus/domain/policy/retention.rb

@@ -1,26 +0,0 @@
-module Textus
-  module Domain
-    module Policy
-      # Lifetime policy for queue/quarantine leaves. Both windows are optional
-      # durations (see Domain::Duration). `expire_after` deletes; `archive_after`
-      # moves the leaf aside. When both are set, expire wins once its (longer)
-      # window is exceeded.
-      class Retention
-        attr_reader :expire_after, :archive_after
-
-        def initialize(expire_after: nil, archive_after: nil)
-          @expire_after  = Textus::Domain::Duration.seconds(expire_after)
-          @archive_after = Textus::Domain::Duration.seconds(archive_after)
-        end
-
-        # :expire | :archive | nil for a leaf of the given age (seconds).
-        def action_for(age_seconds)
-          return :expire  if @expire_after  && age_seconds > @expire_after
-          return :archive if @archive_after && age_seconds > @archive_after
-
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/textus/domain/retention.rb

@@ -1,44 +0,0 @@
-module Textus
-  module Domain
-    # Reports leaves whose age (now - file mtime) exceeds a retention window.
-    # Each row is { "key", "path", "action" => "expire"|"archive", "age_seconds" }.
-    class Retention
-      def initialize(manifest:, file_stat:, clock:)
-        @manifest  = manifest
-        @file_stat = file_stat
-        @clock     = clock
-      end
-
-      def call(prefix: nil, zone: nil)
-        @manifest.data.entries
-                 .select { |m| entry_matches?(m, prefix: prefix, zone: zone) }
-                 .flat_map { |m| rows_for(m) }
-      end
-
-      private
-
-      def rows_for(mentry)
-        policy = @manifest.rules.for(mentry.key).retention
-        return [] if policy.nil?
-
-        @manifest.resolver.enumerate(prefix: mentry.key).filter_map do |row|
-          path = row[:path]
-          next unless @file_stat.exists?(path)
-
-          age = (@clock.now - @file_stat.mtime(path)).to_i
-          action = policy.action_for(age)
-          next if action.nil?
-
-          { "key" => row[:key], "path" => path, "action" => action.to_s, "age_seconds" => age }
-        end
-      end
-
-      def entry_matches?(mentry, prefix:, zone:)
-        return false if zone && mentry.zone != zone
-        return false if prefix && !(mentry.key == prefix || mentry.key.start_with?("#{prefix}."))
-
-        true
-      end
-    end
-  end
-end

data/lib/textus/domain/staleness/intake_check.rb

@@ -1,54 +0,0 @@
-require "time"
-
-module Textus
-  module Domain
-    class Staleness
-      # Reports TTL-exceeded staleness for intake-handler entries. Returns an
-      # Array of row hashes (possibly empty) per entry.
-      class IntakeCheck
-        def initialize(manifest:, file_stat:, clock:)
-          @manifest  = manifest
-          @file_stat = file_stat
-          @clock     = clock
-        end
-
-        def rows_for(mentry)
-          return [] unless mentry.is_a?(Textus::Manifest::Entry::Intake)
-
-          ttl = @manifest.rules.for(mentry.key).fetch&.ttl_seconds
-          return [] unless ttl
-
-          path = Textus::Key::Path.resolve(@manifest.data, mentry)
-          reason = ttl_reason(mentry, path, ttl)
-          reason ? [row(mentry, path, reason)] : []
-        end
-
-        private
-
-        def ttl_reason(mentry, path, ttl)
-          return "never fetched" unless @file_stat.exists?(path)
-
-          last_str = last_fetched_of(mentry, path)
-          return "never fetched (no last_fetched_at)" if last_str.nil?
-
-          last = parse_time(last_str)
-          "ttl exceeded (#{ttl}s)" if last.nil? || (@clock.now - last) > ttl
-        end
-
-        def last_fetched_of(mentry, path)
-          Entry.for_format(mentry.format).parse(@file_stat.read(path), path: path)["_meta"]["last_fetched_at"]
-        end
-
-        def parse_time(str)
-          Time.parse(str.to_s)
-        rescue StandardError
-          nil
-        end
-
-        def row(mentry, path, reason)
-          { "key" => mentry.key, "path" => path, "handler" => mentry.handler, "reason" => reason }
-        end
-      end
-    end
-  end
-end