textus 0.26.0 → 0.30.0

data/lib/textus/cli.rb

@@ -14,13 +14,6 @@ module Textus
           .to_h { |k| [k.command_name, k] }
     end
 
-    # Backward-compat constant; callers should prefer `CLI.verbs`.
-    def self.const_missing(name)
-      return verbs.freeze if name == :VERBS
-
-      super
-    end
-
     def self.run(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, cwd: Dir.pwd)
       new(stdin: stdin, stdout: stdout, stderr: stderr, cwd: cwd).run(argv)
     end
@@ -34,22 +27,25 @@ module Textus
     end
 
     def run(argv)
-      OptionParser.new { |o| o.on("--root=PATH") { |v| @root_arg = v } }.order!(argv)
+      # Define --version/--help ourselves so OptionParser doesn't intercept them
+      # with its built-in handlers (which print "version unknown" and a bare usage
+      # line, then exit before we ever reach the verb dispatch below).
+      show_version = false
+      show_help = false
+      OptionParser.new do |o|
+        o.on("--root=PATH") { |v| @root_arg = v }
+        o.on("--version", "-v") { show_version = true }
+        o.on("--help", "-h") { show_help = true }
+      end.order!(argv)
+
+      return @stdout.puts(VERSION) || 0 if show_version
+      return print_help || 0 if show_help
+
       verb = argv.shift
       raise UsageError.new("missing verb") if verb.nil?
 
-      result =
-        case verb
-        when "--version", "-v" then @stdout.puts(VERSION)
-                                    0
-        when "--help", "-h"    then print_help
-                                    0
-        else
-          klass = self.class.verbs[verb] or raise UsageError.new("unknown verb: #{verb}")
-          dispatch(klass, argv)
-        end
-
-      coerce_exit_code(result)
+      klass = self.class.verbs[verb] or raise UsageError.new("unknown verb: #{verb}")
+      coerce_exit_code(dispatch(klass, argv))
     rescue Textus::Error => e
       emit_error(e)
     end
@@ -101,9 +97,9 @@ module Textus
           textus doctor
           textus boot
 
-          textus key {mv,uid,normalize}
-          textus rule {list,explain}
-          textus schema {show,init,diff,migrate}
+          textus key {delete,mv,uid}
+          textus rule {explain,lint,list}
+          textus schema {diff,init,migrate,show}
           textus hook {list,run}
       HELP
     end

data/lib/textus/container.rb

@@ -0,0 +1,23 @@
+module Textus
+  # Single capability record handed to every use case. Replaces the
+  # ReadCaps/WriteCaps/HookCaps trio from 0.26.x. Built once per Store.
+  Container = Data.define(
+    :manifest, :file_store, :schemas, :root,
+    :audit_log, :events, :rpc, :authorizer
+  )
+
+  class Container
+    def self.from_store(store)
+      new(
+        manifest: store.manifest,
+        file_store: store.file_store,
+        schemas: store.schemas,
+        root: store.root,
+        audit_log: store.audit_log,
+        events: store.events,
+        rpc: store.rpc,
+        authorizer: Textus::Domain::Authorizer.new(manifest: store.manifest),
+      )
+    end
+  end
+end

data/lib/textus/dispatcher.rb

@@ -0,0 +1,57 @@
+module Textus
+  # Static verb → use-case map. Canonical lookup as of 0.27.0; replaces the
+  # Application::UseCase registry whose entries were populated by file-load
+  # side effects in 0.26.x.
+  module Dispatcher
+    VERBS = {
+      # Write
+      put: Textus::Write::Put,
+      delete: Textus::Write::Delete,
+      mv: Textus::Write::Mv,
+      accept: Textus::Write::Accept,
+      reject: Textus::Write::Reject,
+      publish: Textus::Write::Publish,
+      refresh: Textus::Write::RefreshWorker,
+      refresh_all: Textus::Write::RefreshAll,
+      retention_sweep: Textus::Write::RetentionSweep,
+
+      # Read
+      get: Textus::Read::Get,
+      get_or_refresh: Textus::Read::GetOrRefresh,
+      list: Textus::Read::List,
+      where: Textus::Read::Where,
+      uid: Textus::Read::Uid,
+      blame: Textus::Read::Blame,
+      audit: Textus::Read::Audit,
+      freshness: Textus::Read::Freshness,
+      stale: Textus::Read::Stale,
+      deps: Textus::Read::Deps,
+      rdeps: Textus::Read::Rdeps,
+      pulse: Textus::Read::Pulse,
+      policy_explain: Textus::Read::PolicyExplain,
+      published: Textus::Read::Published,
+      schema_envelope: Textus::Read::SchemaEnvelope,
+      validate_all: Textus::Read::ValidateAll,
+      doctor: Textus::Read::Doctor,
+      boot: Textus::Read::Boot,
+      retainable: Textus::Read::Retainable,
+
+      # Maintenance
+      migrate: Textus::Maintenance::Migrate,
+      zone_mv: Textus::Maintenance::ZoneMv,
+      key_mv_prefix: Textus::Maintenance::KeyMvPrefix,
+      key_delete_prefix: Textus::Maintenance::KeyDeletePrefix,
+      rule_lint: Textus::Maintenance::RuleLint,
+    }.freeze
+
+    def self.fetch(verb)
+      VERBS.fetch(verb.to_sym) { raise UsageError.new("unknown verb: #{verb.inspect}") }
+    end
+
+    # Single home for the uniform use-case invocation protocol (ADR 0023):
+    # look up the verb, construct on (container:, call:), and invoke #call.
+    def self.invoke(verb, container:, call:, args: [], kwargs: {})
+      fetch(verb).new(container: container, call: call).call(*args, **kwargs)
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Textus
       class AuditLog < Check
         def call
           path = File.join(root, "audit.log")
-          Textus::Infra::AuditLog.new(root).verify_integrity.map do |v|
+          Textus::Ports::AuditLog.new(root).verify_integrity.map do |v|
             {
               "code" => "audit.parse_error",
               "level" => "warning",

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

@@ -3,7 +3,7 @@ module Textus
     class Check
       class SchemaViolations < Check
         def call
-          res = @session.validate_all
+          res = dispatch(:validate_all)
           res["violations"].map do |v|
             fix = v["expected"] &&
                   "field '#{v["field"]}' should be written by '#{v["expected"]}' (last writer: #{v["last_writer"]})"

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

@@ -3,22 +3,24 @@ module Textus
     class Check
       class Sentinels < Check
         def call
-          dir = File.join(root, "sentinels")
-          return [] unless File.directory?(dir)
+          store      = Textus::Ports::SentinelStore.new
+          file_stat  = Textus::Ports::Storage::FileStat.new
+          dir        = File.join(root, "sentinels")
+          return [] unless file_stat.directory?(dir)
 
           repo_root = File.dirname(root)
-          Dir.glob(File.join(dir, "**", "*#{Textus::Domain::Sentinel::SUFFIX}")).flat_map do |sentinel_path|
-            inspect_sentinel(sentinel_path, repo_root)
+          file_stat.glob(File.join(dir, "**", "*#{Textus::Ports::SentinelStore::SUFFIX}")).flat_map do |sentinel_path|
+            inspect_sentinel(sentinel_path, repo_root, store, file_stat)
           end
         end
 
         private
 
-        def inspect_sentinel(sentinel_path, repo_root)
-          sentinel = Textus::Domain::Sentinel.load(sentinel_path, repo_root)
+        def inspect_sentinel(sentinel_path, repo_root, store, file_stat)
+          sentinel = store.load(sentinel_path, repo_root)
           return [parse_error_issue(sentinel_path)] if sentinel.nil?
-          return [orphan_issue(sentinel_path, sentinel)] if sentinel.orphan?
-          return [drift_issue(sentinel)] if sentinel.drift?
+          return [orphan_issue(sentinel_path, sentinel)] if sentinel.orphan?(file_stat)
+          return [drift_issue(sentinel)] if sentinel.drift?(file_stat)
 
           []
         end

data/lib/textus/doctor/check.rb

@@ -14,8 +14,8 @@ module Textus
                           .downcase
       end
 
-      def initialize(session)
-        @session = session
+      def initialize(container)
+        @container = container
       end
 
       def call
@@ -24,9 +24,19 @@ module Textus
 
       protected
 
-      def root     = @session.read_caps.root
-      def manifest = @session.read_caps.manifest
-      def rpc      = @session.rpc
+      def root     = @container.root
+      def manifest = @container.manifest
+      def rpc      = @container.rpc
+
+      # Dispatch a verb through the single use-case invocation seam (ADR 0026).
+      def dispatch(verb, *args, **kwargs)
+        Textus::Dispatcher.invoke(
+          verb,
+          container: @container,
+          call: Textus::Call.build(role: Textus::Role::DEFAULT),
+          args: args, kwargs: kwargs
+        )
+      end
     end
   end
 end

data/lib/textus/doctor.rb

@@ -30,7 +30,7 @@ module Textus
 
     module_function
 
-    def run(session, checks: nil)
+    def build(container:, checks: nil)
       selected_keys = checks ? Array(checks).map(&:to_s) : ALL_CHECKS
       unknown = selected_keys - ALL_CHECKS
       unless unknown.empty?
@@ -40,8 +40,8 @@ module Textus
       end
 
       selected = CHECKS.select { |c| selected_keys.include?(c.name_key) }
-      issues = selected.flat_map { |c| c.new(session).call }
-      issues.concat(run_registered_checks(session))
+      issues = selected.flat_map { |c| c.new(container).call }
+      issues.concat(run_registered_checks(container))
 
       summary = LEVELS.to_h { |l| [l, issues.count { |i| i["level"] == l }] }
       {
@@ -52,13 +52,13 @@ module Textus
       }
     end
 
-    def run_registered_checks(session)
-      session.rpc.names(:validate).flat_map { |name| invoke_registered_check(session, name) }
+    def run_registered_checks(container)
+      container.rpc.names(:validate).flat_map { |name| invoke_registered_check(container, name) }
     end
 
-    def invoke_registered_check(session, name)
+    def invoke_registered_check(container, name)
       result = Timeout.timeout(DOCTOR_CHECK_TIMEOUT_SECONDS) do
-        session.rpc.invoke(:validate, name, caps: session.write_caps)
+        container.rpc.invoke(:validate, name, caps: container)
       end
       return result.map { |h| h.transform_keys(&:to_s) } if result.is_a?(Array)
 

data/lib/textus/domain/authorizer.rb

@@ -3,8 +3,8 @@
 module Textus
   module Domain
     # Authorization service. Single source of truth for "given a manifest
-    # entry and a role, may this caller read/write?". Extracted from
-    # Application::Context so the rule lives in Domain alongside Permission.
+    # entry and a role, may this caller read/write?". Lives in Domain
+    # alongside Permission.
     class Authorizer
       def initialize(manifest:)
         @manifest = manifest

data/lib/textus/domain/duration.rb

@@ -0,0 +1,22 @@
+module Textus
+  module Domain
+    # Parses a duration value into whole seconds. Accepts a bare integer (or
+    # integer-string) of seconds, or `<n><unit>` with unit s/m/h/d. Returns
+    # nil for nil or any unparseable value.
+    module Duration
+      UNIT_SECONDS = { "s" => 1, "m" => 60, "h" => 3600, "d" => 86_400 }.freeze
+
+      def self.seconds(value)
+        return nil if value.nil?
+
+        str = value.to_s.strip
+        return str.to_i if str.match?(/\A\d+\z/)
+
+        m = str.match(/\A(\d+)\s*([smhd])\z/)
+        return nil unless m
+
+        m[1].to_i * UNIT_SECONDS.fetch(m[2])
+      end
+    end
+  end
+end

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

@@ -21,21 +21,7 @@ module Textus
         end
 
         def ttl_seconds
-          return nil if @ttl.nil?
-
-          str = @ttl.to_s.strip
-          return str.to_i if str.match?(/\A\d+\z/)
-
-          m = str.match(/\A(\d+)\s*([smhd])\z/)
-          return nil unless m
-
-          n = m[1].to_i
-          case m[2]
-          when "s" then n
-          when "m" then n * 60
-          when "h" then n * 3600
-          when "d" then n * 86_400
-          end
+          Textus::Domain::Duration.seconds(@ttl)
         end
 
         def to_freshness_policy

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,44 @@
+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/sentinel.rb

@@ -1,69 +1,15 @@
-require "json"
 require "digest"
-require "fileutils"
 
 module Textus
   module Domain
-    # Value object for sentinel files written by Infra::Publisher and inspected
-    # by Doctor::Check::Sentinels. Owns the JSON shape ({source, target,
-    # sha256, mode}) and the on-disk path layout (<store_root>/sentinels/
-    # <target-rel-to-repo>.textus-managed.json). Target/source are repo-relative
-    # when the published file is under the repo root, absolute otherwise.
+    # Pure value object representing a published-file sentinel. Holds the
+    # recorded target path, source path, sha256 checksum, and publish mode.
+    # Has no filesystem I/O — path layout and persistence live in
+    # Ports::SentinelStore; predicate methods accept a FileStat port for
+    # existence and content checks.
     class Sentinel
-      SUFFIX = ".textus-managed.json".freeze
-      DIR    = "sentinels".freeze
-
       attr_reader :target, :source, :sha256, :mode
 
-      def self.write!(target:, source:, store_root:)
-        path = sentinel_path(target, store_root)
-        FileUtils.mkdir_p(File.dirname(path))
-        repo_root = File.dirname(store_root)
-        File.write(path, JSON.generate(
-                           "source" => rel_or_abs(source, repo_root),
-                           "target" => rel_or_abs(target, repo_root),
-                           "sha256" => Digest::SHA256.hexdigest(File.binread(target)),
-                           "mode" => "copy",
-                         ))
-      end
-
-      def self.load(path, repo_root)
-        raw = JSON.parse(File.read(path))
-        new(
-          target: absolutize(raw["target"], repo_root),
-          source: absolutize(raw["source"], repo_root),
-          sha256: raw["sha256"],
-          mode: raw["mode"],
-        )
-      rescue JSON::ParserError, Errno::ENOENT
-        nil
-      end
-
-      def self.sentinel_path(target, store_root)
-        repo_root = File.dirname(store_root)
-        rel = relative_to(target, repo_root) || File.basename(target)
-        File.join(store_root, DIR, rel + SUFFIX)
-      end
-
-      def self.rel_or_abs(path, repo_root)
-        relative_to(path, repo_root) || File.expand_path(path)
-      end
-
-      def self.relative_to(path, repo_root)
-        path = File.expand_path(path)
-        base = File.expand_path(repo_root)
-        return nil unless path.start_with?(base + File::SEPARATOR)
-
-        path[(base.length + 1)..]
-      end
-
-      def self.absolutize(path, repo_root)
-        return path if path.nil?
-        return path if File.absolute_path?(path)
-
-        File.expand_path(path, repo_root)
-      end
-
       def initialize(target:, source:, sha256:, mode:)
         @target = target
         @source = source
@@ -71,15 +17,13 @@ module Textus
         @mode = mode
       end
 
-      def orphan?
-        @target.nil? || !File.exist?(@target)
-      end
+      def orphan?(file_stat) = @target.nil? || !file_stat.exists?(@target)
 
-      def drift?
-        return false if orphan?
+      def drift?(file_stat)
+        return false if orphan?(file_stat)
         return false if @sha256.nil?
 
-        Digest::SHA256.hexdigest(File.binread(@target)) != @sha256
+        Digest::SHA256.hexdigest(file_stat.read(@target)) != @sha256
       end
     end
   end

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

@@ -8,34 +8,43 @@ module Textus
       # entry's `_meta.generated.at` timestamp. Returns an Array of row hashes
       # (possibly empty) per entry.
       class GeneratorCheck
-        def initialize(manifest:)
-          @manifest = manifest
+        def initialize(manifest:, file_stat:)
+          @manifest  = manifest
+          @file_stat = file_stat
         end
 
         def rows_for(mentry)
-          return [] unless mentry.in_generator_zone?
-          return [] unless mentry.is_a?(Textus::Manifest::Entry::Derived)
-
-          src = mentry.source
-          return [] unless src.is_a?(Textus::Manifest::Entry::Derived::External)
+          return [] unless applicable?(mentry)
 
           path = Textus::Key::Path.resolve(@manifest.data, mentry)
-          return [stale_row(mentry, path, "derived entry has never been generated")] unless File.exist?(path)
+          reason = stale_reason(mentry, path)
+          reason ? [stale_row(mentry, path, reason)] : []
+        end
 
-          parsed = Entry.for_format(mentry.format).parse(File.binread(path), path: path)
-          generated_at = parsed["_meta"].dig("generated", "at")
-          return [stale_row(mentry, path, "missing generated.at frontmatter")] unless generated_at
+        private
 
-          gen_time = parse_time(generated_at)
-          return [stale_row(mentry, path, "unparseable generated.at: #{generated_at.inspect}")] unless gen_time
+        def applicable?(mentry)
+          mentry.in_generator_zone?(@manifest.policy) &&
+            mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+            mentry.source.is_a?(Textus::Manifest::Entry::Derived::External)
+        end
 
-          offender = newest_source_after(src, gen_time)
-          return [stale_row(mentry, path, "source '#{offender}' modified after generated.at")] if offender
+        def stale_reason(mentry, path)
+          return "derived entry has never been generated" unless @file_stat.exists?(path)
 
-          []
+          generated_at = generated_at_of(mentry, path)
+          return "missing generated.at frontmatter" unless generated_at
+
+          gen_time = parse_time(generated_at)
+          return "unparseable generated.at: #{generated_at.inspect}" unless gen_time
+
+          offender = newest_source_after(mentry.source, gen_time)
+          "source '#{offender}' modified after generated.at" if offender
         end
 
-        private
+        def generated_at_of(mentry, path)
+          Entry.for_format(mentry.format).parse(@file_stat.read(path), path: path)["_meta"].dig("generated", "at")
+        end
 
         def parse_time(str)
           Time.parse(str.to_s)
@@ -54,7 +63,7 @@ module Textus
         def check_source(src, gen_time)
           if src.match?(/\A[a-z0-9.][a-z0-9._-]*\z/) && !src.include?("/")
             @manifest.resolver.enumerate(prefix: src).each do |row|
-              return src if File.mtime(row[:path]) > gen_time
+              return src if @file_stat.mtime(row[:path]) > gen_time
             end
             nil
           else
@@ -63,18 +72,29 @@ module Textus
         end
 
         def check_filesystem_source(src, gen_time)
-          abs = File.absolute_path?(src) ? src : File.join(File.dirname(@manifest.data.root), src)
-          if File.directory?(abs)
-            Dir.glob(File.join(abs, "**", "*")).each do |fp|
-              next unless File.file?(fp)
-              return src if File.mtime(fp) > gen_time
-            end
-            nil
-          elsif File.exist?(abs) && File.mtime(abs) > gen_time
+          abs = absolutize_source(src)
+          if @file_stat.directory?(abs)
+            dir_has_newer_file?(abs, gen_time) ? src : nil
+          elsif @file_stat.exists?(abs) && @file_stat.mtime(abs) > gen_time
             src
           end
         end
 
+        def absolutize_source(src)
+          File.absolute_path?(src) ? src : File.join(File.dirname(@manifest.data.root), src)
+        end
+
+        def dir_has_newer_file?(abs, gen_time)
+          @file_stat.glob(File.join(abs, "**", "*")).any? do |fpath|
+            file?(fpath) && @file_stat.mtime(fpath) > gen_time
+          end
+        end
+
+        # FileStat substitute for File.file?: excludes directories but treats
+        # special files (FIFOs/sockets/devices) as regular files — acceptable
+        # because a generator source tree won't contain them.
+        def file?(fpath) = !@file_stat.directory?(fpath) && @file_stat.exists?(fpath)
+
         def stale_row(mentry, path, reason)
           {
             "key" => mentry.key,

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

@@ -6,8 +6,10 @@ module Textus
       # Reports TTL-exceeded staleness for intake-handler entries. Returns an
       # Array of row hashes (possibly empty) per entry.
       class IntakeCheck
-        def initialize(manifest:)
-          @manifest = manifest
+        def initialize(manifest:, file_stat:, clock:)
+          @manifest  = manifest
+          @file_stat = file_stat
+          @clock     = clock
         end
 
         def rows_for(mentry)
@@ -17,19 +19,25 @@ module Textus
           return [] unless ttl
 
           path = Textus::Key::Path.resolve(@manifest.data, mentry)
-          return [row(mentry, path, "never refreshed")] unless File.exist?(path)
+          reason = ttl_reason(mentry, path, ttl)
+          reason ? [row(mentry, path, reason)] : []
+        end
+
+        private
 
-          meta = Entry.for_format(mentry.format).parse(File.binread(path), path: path)["_meta"]
-          last_str = meta["last_refreshed_at"]
-          return [row(mentry, path, "never refreshed (no last_refreshed_at)")] if last_str.nil?
+        def ttl_reason(mentry, path, ttl)
+          return "never refreshed" unless @file_stat.exists?(path)
 
-          last = parse_time(last_str)
-          return [row(mentry, path, "ttl exceeded (#{ttl}s)")] if last.nil? || (Time.now - last) > ttl
+          last_str = last_refreshed_of(mentry, path)
+          return "never refreshed (no last_refreshed_at)" if last_str.nil?
 
-          []
+          last = parse_time(last_str)
+          "ttl exceeded (#{ttl}s)" if last.nil? || (@clock.now - last) > ttl
         end
 
-        private
+        def last_refreshed_of(mentry, path)
+          Entry.for_format(mentry.format).parse(@file_stat.read(path), path: path)["_meta"]["last_refreshed_at"]
+        end
 
         def parse_time(str)
           Time.parse(str.to_s)

data/lib/textus/domain/staleness.rb

@@ -1,10 +1,10 @@
 module Textus
   module Domain
     class Staleness
-      def initialize(manifest:)
+      def initialize(manifest:, file_stat:, clock:)
         @manifest = manifest
-        @generator_check = GeneratorCheck.new(manifest: manifest)
-        @intake_check = IntakeCheck.new(manifest: manifest)
+        @generator_check = GeneratorCheck.new(manifest: manifest, file_stat: file_stat)
+        @intake_check    = IntakeCheck.new(manifest: manifest, file_stat: file_stat, clock: clock)
       end
 
       def call(prefix: nil, zone: nil)