textus 0.18.0 → 0.20.2

data/lib/textus/application/writes/publish.rb

@@ -1,37 +1,102 @@
 module Textus
   module Application
     module Writes
-      # Copies nested-leaf entries to their `publish_each:` targets. Fires
-      # `:file_published` for each copy. Mirror of `Build` for the publish
-      # half — split out from the old Build per ADR 0007.
+      # Single-pass publish use case: materializes Derived entries (template +
+      # projection + external runner) AND copies Leaf/Nested entries to their
+      # publish targets. Replaces the former two-step Build + Publish split.
+      #
+      # Return shape: { "protocol", "built", "published_leaves" }
+      # — wire-compatible with what the `textus build` CLI verb previously
+      #   assembled by merging Build + old Publish results.
       class Publish
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(ctx:, manifest:, file_store:, bus:, root:, store:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @file_store   = file_store
+          @bus          = bus
+          @root         = root
+          @store        = store
+          @hook_context = hook_context
         end
 
         def call(prefix: nil)
-          repo_root = File.dirname(store.root)
-          out = []
-          manifest.entries.each do |mentry|
-            next unless mentry.nested && mentry.publish_each
-            next if prefix && !mentry.key.start_with?(prefix) && !prefix.start_with?("#{mentry.key}.")
+          built  = []
+          leaves = []
+          repo_root = File.dirname(@root)
 
-            manifest.enumerate(prefix: mentry.key).each do |row|
-              next unless row[:manifest_entry].equal?(mentry)
-              next if prefix && !row[:key].start_with?(prefix) && row[:key] != prefix
+          @manifest.entries.each do |mentry|
+            next if prefix && !entry_matches_prefix?(mentry, prefix)
 
-              out << publish_leaf(mentry, row, repo_root)
+            case mentry
+            when Textus::Manifest::Entry::Derived
+              next unless mentry.in_generator_zone?
+
+              result = materialize_derived(mentry, repo_root)
+              built << result if result
+            when Textus::Manifest::Entry::Nested
+              next unless mentry.publish_each
+
+              publish_nested(mentry, repo_root, prefix, leaves)
+            when Textus::Manifest::Entry::Leaf
+              next if Array(mentry.publish_to).empty?
+
+              result = publish_leaf_entry(mentry, repo_root)
+              built << result if result
             end
           end
-          { "protocol" => Textus::PROTOCOL, "published_leaves" => out }
+
+          { "protocol" => Textus::PROTOCOL, "built" => built, "published_leaves" => leaves }
         end
 
         private
 
-        def store = @ctx.store
-        def manifest = store.manifest
+        # Materialize a Derived entry and copy to publish_to targets.
+        def materialize_derived(mentry, repo_root)
+          target_path = Materializer.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+            bus: @bus, root: @root, store: @store
+          ).run(mentry)
 
-        def publish_leaf(mentry, row, repo_root)
+          publish_derived_copies(mentry, target_path, repo_root)
+          fire_build_completed(mentry)
+
+          { "key" => mentry.key, "path" => target_path, "published_to" => mentry.publish_to }
+        end
+
+        def publish_derived_copies(mentry, target_path, repo_root)
+          envelope = reader.call(mentry.key)
+          mentry.publish_to.each do |rel|
+            target_abs = File.join(repo_root, rel)
+            Textus::Infra::Publisher.publish(source: target_path, target: target_abs, store_root: @root)
+            publish_event(:file_published,
+                          key: mentry.key,
+                          envelope: envelope,
+                          source: target_path,
+                          target: target_abs)
+          end
+        end
+
+        def fire_build_completed(mentry)
+          envelope = reader.call(mentry.key)
+          src = mentry.source
+          selects = src.is_a?(Textus::Manifest::Entry::Derived::Projection) ? Array(src.select).compact : []
+          publish_event(:build_completed,
+                        key: mentry.key,
+                        envelope: envelope,
+                        sources: selects)
+        end
+
+        # Publish each leaf under a Nested entry's publish_each pattern.
+        def publish_nested(mentry, repo_root, prefix, accumulator)
+          @manifest.resolver.enumerate(prefix: mentry.key).each do |row|
+            next unless row[:manifest_entry].equal?(mentry)
+            next if prefix && !row[:key].start_with?(prefix) && row[:key] != prefix
+
+            accumulator << publish_nested_leaf(mentry, row, repo_root)
+          end
+        end
+
+        def publish_nested_leaf(mentry, row, repo_root)
           target_rel = mentry.publish_target_for(row[:key])
           target_abs = File.expand_path(File.join(repo_root, target_rel))
           unless target_abs.start_with?(File.expand_path(repo_root) + File::SEPARATOR)
@@ -40,16 +105,57 @@ module Textus
             )
           end
 
-          Textus::Infra::Publisher.publish(source: row[:path], target: target_abs, store_root: store.root)
-          @ctx.bus.publish(:file_published,
-                           store: @ctx.with_role(@ctx.role),
-                           key: row[:key],
-                           envelope: Textus::Application::Reads::Get.new(ctx: @ctx).call(row[:key]),
-                           source: row[:path],
-                           target: target_abs,
-                           correlation_id: @ctx.correlation_id)
+          Textus::Infra::Publisher.publish(source: row[:path], target: target_abs, store_root: @root)
+          publish_event(:file_published,
+                        key: row[:key],
+                        envelope: reader.call(row[:key]),
+                        source: row[:path],
+                        target: target_abs)
           { "key" => row[:key], "source" => row[:path], "target" => target_abs }
         end
+
+        # Publish a standalone Leaf entry that has publish_to targets.
+        def publish_leaf_entry(mentry, repo_root)
+          source_path = @manifest.resolver.resolve(mentry.key).path
+          envelope = reader.call(mentry.key)
+
+          mentry.publish_to.each do |rel|
+            target_abs = File.join(repo_root, rel)
+            Textus::Infra::Publisher.publish(source: source_path, target: target_abs, store_root: @root)
+            publish_event(:file_published,
+                          key: mentry.key,
+                          envelope: envelope,
+                          source: source_path,
+                          target: target_abs)
+          end
+
+          { "key" => mentry.key, "path" => source_path, "published_to" => mentry.publish_to }
+        end
+
+        # Whether the entry should be processed for the given prefix filter.
+        def entry_matches_prefix?(mentry, prefix)
+          return true unless prefix
+
+          case mentry
+          when Textus::Manifest::Entry::Nested
+            # Nested: process if the entry key is a prefix of `prefix` or
+            # `prefix` is a prefix of the entry key (a leaf under it).
+            mentry.key.start_with?(prefix) ||
+              prefix.start_with?("#{mentry.key}.")
+          else
+            mentry.key.start_with?(prefix)
+          end
+        end
+
+        def reader
+          @reader ||= Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          )
+        end
+
+        def publish_event(event, **payload)
+          @bus.publish(event, ctx: @hook_context, **payload)
+        end
       end
     end
   end

data/lib/textus/application/writes/put.rb

@@ -2,16 +2,20 @@ module Textus
   module Application
     module Writes
       class Put
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        def initialize(ctx:, manifest:, envelope_io:, bus:, authorizer:, hook_context:)
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
-        def call(key, meta: nil, body: nil, content: nil, if_etag: nil, suppress_events: false)
-          @ctx.manifest.validate_key!(key)
-          mentry = @ctx.manifest.resolve(key).entry
+        def call(key, meta: nil, body: nil, content: nil, if_etag: nil)
+          @manifest.validate_key!(key)
+          mentry = @manifest.resolver.resolve(key).entry
 
-          @ctx.authorize_write!(mentry)
+          @authorizer.authorize_write!(mentry, role: @ctx.role)
 
           envelope = @envelope_io.write(
             key,
@@ -20,13 +24,10 @@ module Textus
             if_etag: if_etag,
           )
 
-          unless suppress_events
-            @ctx.bus.publish(:entry_put,
-                             store: @ctx.with_role(@ctx.role),
-                             key: key,
-                             envelope: envelope,
-                             correlation_id: @ctx.correlation_id)
-          end
+          @bus.publish(:entry_put,
+                       ctx: @hook_context,
+                       key: key,
+                       envelope: envelope)
 
           envelope
         end

data/lib/textus/application/writes/reject.rb

@@ -1,33 +1,46 @@
+require_relative "authority_gate"
+
 module Textus
   module Application
     module Writes
       class Reject
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        include AuthorityGate
+
+        def initialize(ctx:, manifest:, file_store:, envelope_io:, bus:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @file_store   = file_store
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(pending_key)
-          raise ProposalError.new("only human role can reject proposals; got '#{@ctx.role}'") unless @ctx.role == "human"
+          assert_accept_authority!("reject")
 
-          mentry = @ctx.manifest.resolve(pending_key).entry
+          mentry = @manifest.resolver.resolve(pending_key).entry
           unless mentry.in_proposal_zone?
             raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})")
           end
 
-          env = Textus::Application::Reads::Get.new(ctx: @ctx).call(pending_key)
+          env = Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          ).call(pending_key)
           proposal = env.meta&.dig("proposal") or
             raise ProposalError.new("entry has no proposal block: #{pending_key}")
           target_key = proposal["target_key"] or
             raise ProposalError.new("proposal missing target_key")
 
-          Textus::Application::Writes::Delete.new(ctx: @ctx, envelope_io: @envelope_io).call(pending_key, suppress_events: true)
+          Textus::Application::Writes::Delete.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io,
+            bus: @bus, authorizer: @authorizer, hook_context: @hook_context
+          ).call(pending_key, suppress_events: true)
 
-          @ctx.bus.publish(:proposal_rejected,
-                           store: @ctx.with_role(@ctx.role),
-                           key: pending_key,
-                           target_key: target_key,
-                           correlation_id: @ctx.correlation_id)
+          @bus.publish(:proposal_rejected,
+                       ctx: @hook_context,
+                       key: pending_key,
+                       target_key: target_key)
 
           { "protocol" => PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
         end

data/lib/textus/builder/pipeline.rb

@@ -7,11 +7,15 @@ module Textus
       # Returns a new hash with _meta as the first key, per SPEC §6 ordering.
       def self.call(content_hash, mentry)
         meta = { "generated_at" => Time.now.utc.iso8601 }
-        from = Array(mentry.projection&.fetch("select", nil)).compact
-        meta["from"] = from unless from.empty?
+        if mentry.is_a?(Textus::Manifest::Entry::Derived)
+          src = mentry.source
+          if src.is_a?(Textus::Manifest::Entry::Derived::Projection)
+            from = Array(src.select).compact
+            meta["from"] = from unless from.empty?
+            meta["reduce"] = src.transform if src.transform
+          end
+        end
         meta["template"] = mentry.template if mentry.template
-        reduce = mentry.projection&.dig("transform")
-        meta["reduce"] = reduce if reduce
 
         out = { "_meta" => meta }
         content_hash.each { |k, v| out[k] = v unless k == "_meta" }
@@ -58,22 +62,23 @@ module Textus
         }
       end
 
-      def self.run(store:, mentry:, template_loader:)
+      # rubocop:disable Metrics/ParameterLists
+      def self.run(mentry:, manifest:, reader:, lister:, transform_resolver:, template_loader:,
+                   transform_context: nil, inject_intro: nil)
         # 1. Load sources + project + reduce
         data =
-          if mentry.projection
-            ops = Operations.for(store)
-            Projection.new(
-              reader: ops.method(:get),
-              spec: mentry.projection,
-              lister: ops.method(:list),
-              transform_resolver: ->(name) { store.registry.rpc_callable(:transform_rows, name) },
-              transform_context: Application::Context.system(store),
+          if mentry.is_a?(Textus::Manifest::Entry::Derived) && mentry.projection?
+            Application::Projection.new(
+              reader: reader,
+              spec: mentry.source.to_h.transform_keys(&:to_s),
+              lister: lister,
+              transform_resolver: transform_resolver,
+              transform_context: transform_context,
             ).run
           else
             { "entries" => [], "count" => 0, "generated_at" => Time.now.utc.iso8601 }
           end
-        data = data.merge("intro" => Intro.run(store)) if mentry.inject_intro
+        data = data.merge("intro" => inject_intro.call) if mentry.inject_intro && inject_intro
 
         # 2. Render
         klass = renderers[mentry.format] or
@@ -81,12 +86,13 @@ module Textus
         bytes = klass.new(template_loader: template_loader).call(mentry: mentry, data: data)
 
         # 3. Write (idempotent: skip if only generated_at would differ)
-        target_path = Key::Path.resolve(store.manifest, mentry)
+        target_path = Key::Path.resolve(manifest, mentry)
         FileUtils.mkdir_p(File.dirname(target_path))
         write_if_changed(target_path, bytes, mentry.format)
 
         target_path
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def self.write_if_changed(target_path, bytes, format)
         if File.exist?(target_path)

data/lib/textus/builder/renderer/json.rb

@@ -28,7 +28,10 @@ module Textus
         end
 
         def default_shape(mentry, data)
-          if mentry.projection && mentry.projection["transform"] && data.is_a?(Hash) && !data.key?("entries")
+          has_transform = mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+                          mentry.source.is_a?(Textus::Manifest::Entry::Derived::Projection) &&
+                          mentry.source.transform
+          if has_transform && data.is_a?(Hash) && !data.key?("entries")
             data
           elsif data.is_a?(Hash) && data["entries"].is_a?(Array)
             { "entries" => data["entries"] }

data/lib/textus/builder/renderer/markdown.rb

@@ -8,10 +8,16 @@ module Textus
           raise TemplateError.new("entry '#{mentry.key}': markdown build requires a template") unless mentry.template
 
           body = Mustache.render(@template_loader.call(mentry.template), data)
+          from = if mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+                    mentry.source.is_a?(Textus::Manifest::Entry::Derived::Projection)
+                   Array(mentry.source.select).compact
+                 else
+                   []
+                 end
           frontmatter = {
             "generated" => {
               "at" => Time.now.utc.iso8601,
-              "from" => Array(mentry.projection&.fetch("select", nil)).compact,
+              "from" => from,
             },
           }
           Entry.for_format("markdown").serialize(meta: frontmatter, body: body)

data/lib/textus/builder/renderer/yaml.rb

@@ -28,7 +28,10 @@ module Textus
         end
 
         def default_shape(mentry, data)
-          if mentry.projection && mentry.projection["transform"] && data.is_a?(Hash) && !data.key?("entries")
+          has_transform = mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+                          mentry.source.is_a?(Textus::Manifest::Entry::Derived::Projection) &&
+                          mentry.source.transform
+          if has_transform && data.is_a?(Hash) && !data.key?("entries")
             data
           elsif data.is_a?(Hash) && data["entries"].is_a?(Array)
             { "entries" => data["entries"] }

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

@@ -8,12 +8,10 @@ module Textus
 
         def call(store)
           Textus::Infra::BuildLock.with(root: store.root) do
-            ops = Textus::Operations.for(store, role: "builder")
-            build_res   = ops.build(prefix: prefix)
-            publish_res = ops.publish(prefix: prefix)
-            emit({ "protocol" => Textus::PROTOCOL,
-                   "built" => build_res["built"],
-                   "published_leaves" => publish_res["published_leaves"] })
+            role = store.manifest.roles_with_kind(:generator).first || "builder"
+            ops = Textus::Operations.for(store, role: role)
+            result = ops.publish(prefix: prefix)
+            emit(result)
           end
         end
       end

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

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

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

@@ -26,13 +26,12 @@ module Textus
             end
           end
 
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          callable = store.registry.rpc_callable(:resolve_intake, name)
-          view = Application::Context.new(store: store, role: role)
+          Role.resolve(flag: as_flag, env: ENV, root: store.root)
+          callable = store.bus.rpc_callable(:resolve_intake, name)
 
           begin
             Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do
-              callable.call(config: {}, store: view, args: args)
+              callable.call(config: {}, store: store, args: args)
             end
           rescue Timeout::Error
             raise UsageError.new(

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

@@ -7,7 +7,7 @@ module Textus
 
         option :event_filter, "--event=E"
 
-        def call(store) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def call(store) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           subcommand = positional.first
           if subcommand
             raise UsageError.new("hook requires 'list'") unless subcommand == "list"
@@ -16,15 +16,15 @@ module Textus
           end
 
           rows = []
-          Textus::Hooks::Registry::EVENTS.each do |event, spec|
+          Textus::Hooks::Bus::EVENTS.each do |event, spec|
             mode = spec[:mode].to_s
             case spec[:mode]
             when :rpc
-              store.registry.rpc_names(event).each do |name|
+              store.bus.rpc_names(event).each do |name|
                 rows << { "event" => event.to_s, "mode" => mode, "name" => name.to_s }
               end
             when :pubsub
-              store.registry.pubsub_handlers(event).each do |h|
+              store.bus.pubsub_handlers(event).each do |h|
                 row = { "event" => event.to_s, "mode" => mode, "name" => h[:name].to_s }
                 row["keys"] = Array(h[:keys]) if h[:keys]
                 rows << row
@@ -32,7 +32,7 @@ module Textus
             end
           end
           store.manifest.entries.each do |e|
-            e.events.each do |evt, defs|
+            (e.respond_to?(:events) ? e.events : {}).each do |evt, defs|
               Array(defs).each do |defn|
                 next unless defn["exec"]
 

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

@@ -17,12 +17,11 @@ module Textus
           raw = @stdin.read
           payload =
             if fetch_name
-              callable = store.registry.rpc_callable(:resolve_intake, fetch_name)
+              callable = store.bus.rpc_callable(:resolve_intake, fetch_name)
               result =
                 begin
                   Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do
-                    callable.call(config: { "bytes" => raw },
-                                  store: Textus::Application::Context.new(store: store, role: role), args: {})
+                    callable.call(config: { "bytes" => raw }, store: store, args: {})
                   end
                 rescue Timeout::Error
                   raise UsageError.new(

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

@@ -10,8 +10,7 @@ module Textus
         option :as_flag, "--as=ROLE"
 
         def call(store)
-          ctx = context_for(store)
-          result = Textus::Application::Refresh::All.call(ctx, prefix: prefix, zone: zone)
+          result = operations_for(store).refresh_all(prefix: prefix, zone: zone)
           emit(result)
           result["ok"] ? 0 : 1
         end

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

@@ -8,8 +8,9 @@ module Textus
         def call
           out = []
           store.manifest.entries.each do |mentry|
-            handler = mentry.intake_handler
-            next if handler.nil?
+            next unless mentry.is_a?(Textus::Manifest::Entry::Intake)
+
+            handler = mentry.handler
 
             allow = store.manifest.rules_for(mentry.key).handler_allowlist
             next if allow.nil?

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

@@ -8,11 +8,11 @@ module Textus
           return out unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
-            registry = Textus::Hooks::Registry.new
+            bus = Textus::Hooks::Bus.new
             Textus.drain_hook_blocks
             begin
               load(f)
-              Textus.drain_hook_blocks.each { |b| b.call(registry) }
+              Textus.drain_hook_blocks.each { |b| b.call(bus) }
             end
           rescue StandardError, ScriptError => e
             out << {

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

@@ -5,12 +5,13 @@ module Textus
         def call
           out = []
           store.manifest.entries.each do |entry|
-            next unless entry.nested
+            next unless entry.nested?
 
             base = File.join(store.root, "zones", entry.path)
             next unless File.directory?(base)
 
-            entry.index_filename ? check_index_paths(entry, base, out) : check_all_paths(base, out)
+            index_fn = entry.respond_to?(:index_filename) ? entry.index_filename : nil
+            index_fn ? check_index_paths(entry, index_fn, base, out) : check_all_paths(base, out)
           end
           out
         end
@@ -31,8 +32,8 @@ module Textus
         # segments leading to each index file participate in keys. Sibling
         # files and unrelated subtrees are not enumerated and must not be
         # flagged. Each illegal segment is reported once per path.
-        def check_index_paths(entry, base, out)
-          Dir.glob(File.join(base, "**", entry.index_filename)).each do |fp|
+        def check_index_paths(_entry, index_fn, base, out)
+          Dir.glob(File.join(base, "**", index_fn)).each do |fp|
             rel = fp.sub(%r{\A#{Regexp.escape(base)}/?}, "")
             File.dirname(rel).split("/").reject { |s| s.empty? || s == "." }.each do |seg|
               next if seg.match?(Key::Grammar::SEGMENT)
@@ -43,15 +44,14 @@ module Textus
         end
 
         def issue(abs_path, stem)
-          proposed = Textus::MigrateKeys.normalize(stem)
           {
             "code" => "key.illegal",
             "level" => "error",
             "subject" => abs_path,
             "path" => abs_path,
-            "proposed_key" => proposed,
             "message" => "illegal key segment '#{stem}' at #{abs_path}",
-            "fix" => "run 'textus key normalize --dry-run' then '--write' to rename to '#{proposed}'",
+            "fix" => "rename the file/directory so each segment matches [a-z0-9][a-z0-9-]* " \
+                     "(lowercase, digits, hyphens)",
           }
         end
 

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

@@ -6,7 +6,7 @@ module Textus
 
         def call
           declared = collect_declared_handlers
-          registered = store.registry.rpc_names(:resolve_intake).to_set
+          registered = store.bus.rpc_names(:resolve_intake).to_set
 
           out = (declared - registered).map do |name|
             {
@@ -36,7 +36,7 @@ module Textus
         def collect_declared_handlers
           set = Set.new
           store.manifest.entries.each do |mentry|
-            set << mentry.intake_handler.to_sym if mentry.intake_handler
+            set << mentry.handler.to_sym if mentry.is_a?(Textus::Manifest::Entry::Intake)
           end
           set
         end

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

@@ -4,7 +4,7 @@ module Textus
       class ManifestFiles < Check
         def call
           store.manifest.entries.each_with_object([]) do |entry, out|
-            next if entry.nested
+            next if entry.nested?
 
             path = Textus::Key::Path.resolve(store.manifest, entry)
             next if File.exist?(path)

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

@@ -19,7 +19,7 @@ module Textus
             "code" => "protocol_mismatch",
             "severity" => "error",
             "message" => "Store reports version=#{version.inspect}; this gem expects textus/3.",
-            "hint" => "Install textus 0.11.x to run the migrator, then upgrade to this version. See https://github.com/patrick204nqh/textus/blob/main/CHANGELOG.md#0110",
+            "hint" => "Upgrade the store's manifest version to textus/3 (see CHANGELOG for breaking changes).",
           }]
         end
 
@@ -38,7 +38,7 @@ module Textus
             "level" => "error",
             "subject" => path,
             "message" => "Store reports version=#{version.inspect}; this gem expects textus/3.",
-            "fix" => "Install textus 0.11.x to run the migrator, then upgrade to this version. See https://github.com/patrick204nqh/textus/blob/main/CHANGELOG.md#0110",
+            "fix" => "Upgrade the store's manifest version to textus/3 (see CHANGELOG for breaking changes).",
           }]
         end
       end