textus 0.18.0 → 0.20.2

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

@@ -5,16 +5,17 @@ module Textus
         def call
           out = []
           store.manifest.entries.each do |entry|
-            next if entry.template.nil?
+            template = entry.respond_to?(:template) ? entry.template : nil
+            next if template.nil?
 
-            tp = File.join(store.root, "templates", entry.template)
+            tp = File.join(store.root, "templates", template)
             next if File.exist?(tp)
 
             out << {
               "code" => "template.missing",
               "level" => "error",
               "subject" => entry.key,
-              "message" => "template '#{entry.template}' not found at #{tp}",
+              "message" => "template '#{template}' not found at #{tp}",
               "fix" => "create the file at #{tp} or update the entry's template: field",
             }
           end

data/lib/textus/doctor.rb

@@ -54,11 +54,10 @@ module Textus
 
     def run_registered_checks(store)
       out = []
-      view = Application::Context.system(store)
-      store.registry.rpc_names(:validate).each do |name|
-        callable = store.registry.rpc_callable(:validate, name)
+      store.bus.rpc_names(:validate).each do |name|
+        callable = store.bus.rpc_callable(:validate, name)
         begin
-          result = Timeout.timeout(DOCTOR_CHECK_TIMEOUT_SECONDS) { callable.call(store: view) }
+          result = Timeout.timeout(DOCTOR_CHECK_TIMEOUT_SECONDS) { callable.call(store: store) }
           if result.is_a?(Array)
             out.concat(result.map { |h| h.transform_keys(&:to_s) })
           else

data/lib/textus/domain/authorizer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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.
+    class Authorizer
+      def initialize(manifest:)
+        @manifest = manifest
+      end
+
+      def can_write?(zone, role:)
+        @manifest.permission_for(zone.to_s).allows_write?(role)
+      end
+
+      def can_read?(zone, role:)
+        @manifest.permission_for(zone.to_s).allows_read?(role)
+      end
+
+      def authorize_write!(mentry, role:)
+        return if can_write?(mentry.zone, role: role)
+
+        writers = @manifest.zone_writers(mentry.zone)
+        raise WriteForbidden.new(mentry.key, mentry.zone, writers: writers)
+      end
+
+      def authorize_read!(mentry, role:)
+        return if can_read?(mentry.zone, role: role)
+
+        readers = @manifest.zone_readers[mentry.zone]
+        readers = nil if readers == :all
+        raise ReadForbidden.new(mentry.key, mentry.zone, readers: readers)
+      end
+    end
+  end
+end

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

@@ -2,14 +2,16 @@ module Textus
   module Domain
     module Policy
       class Promote
-        KNOWN = %i[schema_valid human_accept].freeze
+        KNOWN = %i[schema_valid accept_authority_signed].freeze
         attr_reader :requires
 
         def initialize(requires:)
           syms = Array(requires).map { |r| r.to_s.to_sym }
           unknown = syms - KNOWN
           unless unknown.empty?
-            raise Textus::UsageError.new("unknown promote requirement: #{unknown.first.inspect} (known: #{KNOWN.join(", ")})")
+            raise Textus::UsageError.new(
+              "unknown promote requirement: #{unknown.first.inspect} (known: #{KNOWN.join(", ")})",
+            )
           end
 
           @requires = syms

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

@@ -2,6 +2,8 @@ module Textus
   module Domain
     module Policy
       class Refresh
+        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)

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

@@ -14,9 +14,10 @@ module Textus
 
         def rows_for(mentry)
           return [] unless mentry.in_generator_zone?
+          return [] unless mentry.is_a?(Textus::Manifest::Entry::Derived)
 
-          gen = mentry.generator
-          return [] unless gen
+          src = mentry.source
+          return [] unless src.is_a?(Textus::Manifest::Entry::Derived::External)
 
           path = Textus::Key::Path.resolve(@manifest, mentry)
           return [stale_row(mentry, path, "derived entry has never been generated")] unless File.exist?(path)
@@ -28,7 +29,7 @@ module Textus
           gen_time = parse_time(generated_at)
           return [stale_row(mentry, path, "unparseable generated.at: #{generated_at.inspect}")] unless gen_time
 
-          offender = newest_source_after(gen, gen_time)
+          offender = newest_source_after(src, gen_time)
           return [stale_row(mentry, path, "source '#{offender}' modified after generated.at")] if offender
 
           []
@@ -42,8 +43,8 @@ module Textus
           nil
         end
 
-        def newest_source_after(gen, gen_time)
-          Array(gen["sources"]).each do |src|
+        def newest_source_after(external_src, gen_time)
+          Array(external_src.sources).each do |src|
             offender = check_source(src, gen_time)
             return offender if offender
           end
@@ -52,7 +53,7 @@ module Textus
 
         def check_source(src, gen_time)
           if src.match?(/\A[a-z0-9.][a-z0-9._-]*\z/) && !src.include?("/")
-            @manifest.enumerate(prefix: src).each do |row|
+            @manifest.resolver.enumerate(prefix: src).each do |row|
               return src if File.mtime(row[:path]) > gen_time
             end
             nil
@@ -78,7 +79,7 @@ module Textus
           {
             "key" => mentry.key,
             "path" => path,
-            "generator" => mentry.generator,
+            "generator" => mentry.raw["compute"],
             "reason" => reason,
           }
         end

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

@@ -11,7 +11,7 @@ module Textus
         end
 
         def rows_for(mentry)
-          return [] unless mentry.intake_handler
+          return [] unless mentry.is_a?(Textus::Manifest::Entry::Intake)
 
           ttl = @manifest.rules_for(mentry.key).refresh&.ttl_seconds
           return [] unless ttl
@@ -38,7 +38,7 @@ module Textus
         end
 
         def row(mentry, path, reason)
-          { "key" => mentry.key, "path" => path, "handler" => mentry.intake_handler, "reason" => reason }
+          { "key" => mentry.key, "path" => path, "handler" => mentry.handler, "reason" => reason }
         end
       end
     end

data/lib/textus/hooks/builtin.rb

@@ -7,22 +7,22 @@ module Textus
   module Hooks
     module Builtin
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def self.register_all(registry)
-        registry.on(:resolve_intake, :json) do |store:, config:, args:|
+      def self.register_all(bus)
+        bus.on(:resolve_intake, :json) do |store:, config:, args:|
           _ = store
           _ = args
           data = JSON.parse(config["bytes"].to_s)
           { _meta: {}, body: YAML.dump(data) }
         end
 
-        registry.on(:resolve_intake, :csv) do |store:, config:, args:|
+        bus.on(:resolve_intake, :csv) do |store:, config:, args:|
           _ = store
           _ = args
           rows = CSV.parse(config["bytes"].to_s, headers: true).map(&:to_h)
           { _meta: {}, body: YAML.dump(rows) }
         end
 
-        registry.on(:resolve_intake, :"markdown-links") do |store:, config:, args:|
+        bus.on(:resolve_intake, :"markdown-links") do |store:, config:, args:|
           _ = store
           _ = args
           links = config["bytes"].to_s.scan(%r{\[([^\]]+)\]\((https?://[^)\s]+)\)}).map do |text, href|
@@ -31,7 +31,7 @@ module Textus
           { _meta: {}, body: YAML.dump(links) }
         end
 
-        registry.on(:resolve_intake, :"ical-events") do |store:, config:, args:|
+        bus.on(:resolve_intake, :"ical-events") do |store:, config:, args:|
           _ = store
           _ = args
           events = []
@@ -50,7 +50,7 @@ module Textus
           { _meta: {}, body: YAML.dump(events) }
         end
 
-        registry.on(:resolve_intake, :rss) do |store:, config:, args:|
+        bus.on(:resolve_intake, :rss) do |store:, config:, args:|
           _ = store
           _ = args
           doc = REXML::Document.new(config["bytes"].to_s)

data/lib/textus/hooks/bus.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Textus
+  module Hooks
+    class Bus
+      HOOK_TIMEOUT_SECONDS = 2
+
+      class HookTimeout < StandardError; end
+
+      EVENTS = {
+        # RPC events — gem-internal, keep :store
+        resolve_intake: { mode: :rpc, args: %i[store config args] },
+        transform_rows: { mode: :rpc, args: %i[store rows config] },
+        validate: { mode: :rpc, args: %i[store] },
+
+        # Pubsub events — ship :ctx (Hooks::Context) instead of raw store
+        entry_put: { mode: :pubsub, args: %i[ctx key envelope] },
+        entry_deleted: { mode: :pubsub, args: %i[ctx key] },
+        entry_refreshed: { mode: :pubsub, args: %i[ctx key envelope change] },
+        entry_renamed: { mode: :pubsub, args: %i[ctx key from_key to_key envelope] },
+        build_completed: { mode: :pubsub, args: %i[ctx key envelope sources] },
+        proposal_accepted: { mode: :pubsub, args: %i[ctx key target_key] },
+        proposal_rejected: { mode: :pubsub, args: %i[ctx key target_key] },
+        file_published: { mode: :pubsub, args: %i[ctx key envelope source target] },
+        store_loaded: { mode: :pubsub, args: %i[ctx] },
+        refresh_started: { mode: :pubsub, args: %i[ctx key mode] },
+        refresh_failed: { mode: :pubsub, args: %i[ctx key error_class error_message] },
+        refresh_backgrounded: { mode: :pubsub, args: %i[ctx key started_at budget_ms] },
+      }.freeze
+
+      def initialize
+        @rpc    = Hash.new { |h, k| h[k] = {} }
+        @pubsub = Hash.new { |h, k| h[k] = [] }
+        @error_handlers = []
+      end
+
+      def on(event, name, keys: nil, &) = register(event, name, keys: keys, &)
+
+      def register(event, name, keys: nil, &blk)
+        event_sym = event.to_sym
+        spec = EVENTS[event_sym] or raise UsageError.new("unknown event: #{event}")
+        shape_check!(event_sym, spec, blk)
+        name = name.to_sym
+
+        case spec[:mode]
+        when :rpc
+          raise UsageError.new("#{event_sym} '#{name}' already registered") if @rpc[event_sym].key?(name)
+
+          @rpc[event_sym][name] = blk
+        when :pubsub
+          raise UsageError.new("#{event_sym} hook '#{name}' already registered") if @pubsub[event_sym].any? { |h| h[:name] == name }
+
+          @pubsub[event_sym] << { name: name, callable: blk, keys: keys }
+        end
+      end
+
+      def on_error(&block) = @error_handlers << block
+
+      def rpc_callable(event, name)
+        @rpc[event.to_sym][name.to_sym] or raise UsageError.new("unknown #{event}: #{name}")
+      end
+
+      def rpc_names(event)        = @rpc[event.to_sym].keys
+      def pubsub_handlers(event)  = @pubsub[event.to_sym]
+      def listeners(event, key:)  = @pubsub[event.to_sym].select { |h| h[:keys].nil? || matches_any?(h[:keys], key) }
+
+      def publish(event, strict: false, **kwargs)
+        key = kwargs[:key] || "-"
+        fired = []
+        errored = []
+        timed_out = []
+        raised = nil
+
+        @pubsub[event.to_sym].each do |sub|
+          next unless match?(sub[:keys], key)
+
+          outcome, err = invoke(event, sub, key, kwargs)
+          case outcome
+          when :ok        then fired << sub[:name]
+          when :errored   then errored << sub[:name]
+          when :timed_out then timed_out << sub[:name]
+          end
+          raised ||= err if strict && err
+        end
+
+        raise raised if strict && raised
+
+        FireReport.new(fired: fired, errored: errored, timed_out: timed_out)
+      end
+
+      private
+
+      def invoke(event, sub, key, kwargs)
+        accepted = filter_kwargs(sub[:callable], kwargs)
+        error = nil
+
+        thread = Thread.new do
+          sub[:callable].call(**accepted)
+        rescue StandardError => e
+          error = e
+        end
+
+        if thread.join(HOOK_TIMEOUT_SECONDS).nil?
+          thread.kill
+          err = HookTimeout.new("hook #{sub[:name]} exceeded #{HOOK_TIMEOUT_SECONDS}s on event #{event}")
+          notify_error(event, sub, key, kwargs, err)
+          return [:timed_out, err]
+        end
+
+        if error
+          notify_error(event, sub, key, kwargs, error)
+          return [:errored, error]
+        end
+
+        [:ok, nil]
+      end
+
+      def notify_error(event, sub, key, kwargs, error)
+        @error_handlers.each do |handler|
+          handler.call(event: event, hook: sub[:name], key: key, kwargs: kwargs, error: error)
+        rescue StandardError => e
+          warn "[textus] error handler failed: #{e.class}: #{e.message}"
+        end
+      end
+
+      def filter_kwargs(callable, kwargs)
+        params = callable.parameters
+        return kwargs if params.any? { |type, _| type == :keyrest }
+
+        accepted = params.each_with_object([]) do |(type, name), acc|
+          acc << name if %i[key keyreq].include?(type)
+        end
+        kwargs.slice(*accepted)
+      end
+
+      def shape_check!(event, spec, blk)
+        required = spec[:args]
+        provided = blk.parameters.select { |t, _| %i[keyreq key keyrest].include?(t) } # rubocop:disable Style/HashSlice
+        keyrest  = provided.any? { |t, _| t == :keyrest }
+        missing  = required - provided.map { |_, n| n }
+        return if keyrest || missing.empty?
+
+        raise UsageError.new("#{event} hooks must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})")
+      end
+
+      def match?(globs, key)
+        return true if globs.nil?
+
+        Array(globs).any? { |g| File.fnmatch?(g, key.to_s, File::FNM_PATHNAME) }
+      end
+
+      def matches_any?(globs, key) = match?(globs, key)
+    end
+  end
+end

data/lib/textus/hooks/context.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Textus
+  module Hooks
+    # A narrow handle passed to user hooks in place of the raw Store.
+    # All writes route back through Operations so authorization, audit
+    # logging, and schema validation always fire.
+    class Context
+      attr_reader :role, :correlation_id
+
+      def initialize(ops:)
+        @ops = ops
+        @role = ops.ctx.role
+        @correlation_id = ops.ctx.correlation_id
+      end
+
+      # read
+      def get(key)                = @ops.get(key)
+      def list(**)                = @ops.list(**)
+      def deps(key)               = @ops.deps(key)
+      def freshness(key)          = @ops.freshness(key)
+
+      # write (authorized + audited)
+      def put(key, **)          = @ops.put(key, **)
+      def delete(key, **)       = @ops.delete(key, **)
+      def audit(verb, key:, **) = @ops.store.audit_log.append(role: @role, verb: verb, key: key, **)
+
+      # fan-out
+      def publish_followup(event, **)
+        @ops.store.bus.publish(event, ctx: self, **)
+      end
+
+      def inspect
+        "#<Textus::Hooks::Context role=#{@role} correlation_id=#{@correlation_id}>"
+      end
+    end
+  end
+end

data/lib/textus/hooks/fire_report.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Textus
+  module Hooks
+    # Outcome of a single Dispatcher#publish call.
+    #
+    # fired      — hook names that ran to completion
+    # errored    — hook names that raised
+    # timed_out  — hook names whose worker thread exceeded the deadline
+    #
+    # Callers that care about hook health (tests, strict embedders) can
+    # check #ok? or inspect #failures. The dispatcher itself never raises
+    # on a hook failure unless strict: true was passed to #publish.
+    FireReport = Data.define(:fired, :errored, :timed_out) do
+      def initialize(fired:, errored:, timed_out:)
+        super(fired: fired.dup.freeze, errored: errored.dup.freeze, timed_out: timed_out.dup.freeze)
+      end
+
+      def ok? = errored.empty? && timed_out.empty?
+      def failures = errored + timed_out
+    end
+  end
+end

data/lib/textus/hooks/loader.rb

@@ -1,8 +1,8 @@
 module Textus
   module Hooks
     class Loader
-      def initialize(registry:)
-        @registry = registry
+      def initialize(bus:)
+        @bus = bus
       end
 
       def load_dir(dir)
@@ -18,7 +18,7 @@ module Textus
         end
 
         Textus.drain_hook_blocks.each do |blk|
-          blk.call(@registry)
+          blk.call(@bus)
         rescue StandardError, ScriptError => e
           raise UsageError.new("failed registering hook: #{e.class}: #{e.message}")
         end

data/lib/textus/infra/audit_subscriber.rb

@@ -3,11 +3,11 @@
 module Textus
   module Infra
     # Writes an "event_error" audit row when a user hook raises during
-    # Hooks::Dispatcher publish. Attached at Store boot.
+    # Hooks::Bus publish. Attached at Store boot.
     #
-    # Integration: uses Hooks::Dispatcher#on_error callback (chosen over a
-    # synthetic :hook_error event because the dispatcher already owns the
-    # rescue and the failure is a dispatcher-internal concern, not a domain
+    # Integration: uses Hooks::Bus#on_error callback (chosen over a
+    # synthetic :hook_error event because the bus already owns the
+    # rescue and the failure is a bus-internal concern, not a domain
     # event subscribers should be able to filter by key glob).
     #
     # NOTE (0.16 scope): lifecycle audit rows for verb: "put" / "delete" /

data/lib/textus/infra/event_bus.rb

@@ -1,12 +1,12 @@
 module Textus
   module Infra
     class EventBus
-      def initialize(registry:)
-        @registry = registry
+      def initialize(bus:)
+        @bus = bus
       end
 
       def publish(event, **payload)
-        @registry.pubsub_handlers(event).each do |entry|
+        @bus.pubsub_handlers(event).each do |entry|
           next unless entry[:keys].nil? || matches?(entry[:keys], payload[:key])
 
           entry[:callable].call(**payload)

data/lib/textus/infra/refresh/detached.rb

@@ -21,7 +21,7 @@ module Textus
 
             begin
               store = Textus::Store.new(store_root)
-              Textus::Refresh.call(store, key, as: "runner")
+              Textus::Operations.for(store, role: "runner").refresh(key)
             rescue StandardError
               # Already logged via :refresh_failed; exit cleanly.
             ensure

data/lib/textus/init.rb

@@ -13,8 +13,8 @@ module Textus
         - { name: review,   write_policy: [agent, human],        read_policy: [all] }
         - { name: output,   write_policy: [builder],             read_policy: [all] }
       entries:
-        - { key: identity.self, path: identity/self.md, zone: identity, schema: null, owner: human:self }
-        - { key: working.notes, path: working/notes,    zone: working,  schema: null, owner: human:self, nested: true }
+        - { key: identity.self, path: identity/self.md, zone: identity, schema: null, owner: human:self, kind: leaf }
+        - { key: working.notes, path: working/notes,    zone: working,  schema: null, owner: human:self, nested: true, kind: nested }
     YAML
 
     HOOKS_README = <<~MD
@@ -51,6 +51,7 @@ module Textus
       ```yaml
       entries:
         - key: intake.foo
+          kind: intake
           path: intake/foo.md
           zone: intake
           intake:

data/lib/textus/intro.rb

@@ -18,19 +18,37 @@ module Textus
       "output" => "build-computed outputs; never hand-edited",
     }.freeze
 
-    WRITE_FLOWS = {
-      "human" => "edit files in identity/working zones, then 'textus put KEY --as=human'",
-      "agent" => "propose changes by writing 'review.*' entries with --as=agent and a 'proposal:' frontmatter block; " \
-                 "a human runs 'textus accept' to apply",
-      "runner" => "refresh intake entries with 'textus refresh KEY --as=runner' (uses the entry's declared action)",
-      "builder" => "'textus build' computes output entries from projections; output files are never hand-edited",
+    # Per-kind write-flow templates. Each lambda receives the user-facing role
+    # name and returns a guidance string for that role. Roles whose kind has
+    # no template (e.g. unknown future kinds) are omitted from write_flows.
+    WRITE_FLOW_TEMPLATES = {
+      accept_authority: lambda do |name, _manifest|
+        "edit files in identity/working zones, then 'textus put KEY --as=#{name}'"
+      end,
+      proposer: lambda do |name, manifest|
+        authority = manifest.roles_with_kind(:accept_authority).first || "accept_authority"
+        "propose changes by writing review.* entries with --as=#{name} and a 'proposal:' frontmatter block; " \
+          "the #{authority} role runs 'textus accept' to apply"
+      end,
+      runner: lambda do |name, _manifest|
+        "refresh intake entries with 'textus refresh KEY --as=#{name}' (uses the entry's declared action)"
+      end,
+      generator: lambda do |_name, _manifest|
+        "'textus build' computes output entries from projections; output files are never hand-edited"
+      end,
     }.freeze
 
-    # Static, store-independent guide to the agent-facing protocol. Surfaced
-    # under the new top-level `agent_protocol` key in Intro.run. Recipes
-    # describe CLI verbs (not Ruby Operations) because the audience is an
-    # agent driving textus from the command line.
-    AGENT_PROTOCOL = {
+    def self.write_flows_for(manifest)
+      manifest.role_mapping.each_with_object({}) do |(name, kind), acc|
+        tmpl = WRITE_FLOW_TEMPLATES[kind]
+        acc[name] = tmpl.call(name, manifest) if tmpl
+      end
+    end
+
+    # Static, store-independent parts of the agent-facing protocol. The
+    # `role_resolution` block is derived per-manifest in agent_protocol(...)
+    # because role names are user-configurable.
+    AGENT_PROTOCOL_TEMPLATE = {
       "envelope_shape" => {
         "summary" => "every read/write payload is a JSON envelope with _meta, body, uid, and etag",
         "fields" => {
@@ -41,11 +59,6 @@ module Textus
         },
         "ref" => "SPEC.md §8",
       },
-      "role_resolution" => {
-        "summary" => "write role is resolved in order: --as flag, TEXTUS_ROLE env var, .textus/role file, default human",
-        "roles" => %w[human agent runner builder],
-        "ref" => "SPEC.md §5",
-      },
       "recipes" => {
         "read" => {
           "purpose" => "find and read an entry",
@@ -92,7 +105,7 @@ module Textus
       { "name" => "schema",   "summary" => "field shape for a key family" },
       { "name" => "put",      "summary" => "write an entry; --as=<role>, --stdin payload" },
       { "name" => "accept",   "summary" => "apply a review.* proposal; --as=human only" },
-      { "name" => "key",      "summary" => "key operations: 'key mv', 'key uid', 'key normalize'" },
+      { "name" => "key",      "summary" => "key operations: 'key mv', 'key uid'" },
       { "name" => "delete",   "summary" => "delete an entry; --as=<role>" },
       { "name" => "build",    "summary" => "materialize output entries; publish_to and publish_each fan out copies" },
       { "name" => "refresh",  "summary" => "run an action for an intake entry" },
@@ -105,6 +118,17 @@ module Textus
         "summary" => "list and run registered hooks: 'hook list', 'hook run NAME'" },
     ].freeze
 
+    def self.agent_protocol(manifest)
+      AGENT_PROTOCOL_TEMPLATE.merge(
+        "role_resolution" => {
+          "summary" => "write role is resolved in order: --as flag, TEXTUS_ROLE env var, .textus/role file, " \
+                       "default 'human'",
+          "roles" => manifest.role_mapping.keys,
+          "ref" => "SPEC.md §5",
+        },
+      )
+    end
+
     def self.run(store)
       {
         "protocol" => PROTOCOL_ID,
@@ -112,9 +136,9 @@ module Textus
         "zones" => zones_for(store),
         "entries" => entries_for(store),
         "hooks" => hooks_for(store),
-        "write_flows" => WRITE_FLOWS.dup,
+        "write_flows" => write_flows_for(store.manifest),
         "cli_verbs" => CLI_VERBS.map(&:dup),
-        "agent_protocol" => AGENT_PROTOCOL,
+        "agent_protocol" => agent_protocol(store.manifest),
         "docs" => { "spec" => "SPEC.md", "example" => "examples/claude-plugin/" },
       }
     end
@@ -130,31 +154,31 @@ module Textus
 
     def self.entries_for(store)
       store.manifest.entries.map do |e|
-        derived = store.manifest.zone_writers(e.zone).include?("builder")
+        derived = store.manifest.zone_kinds(e.zone).include?(:generator)
         {
           "key" => e.key,
           "zone" => e.zone,
           "schema" => e.schema,
-          "nested" => e.nested ? true : false,
+          "nested" => e.is_a?(Textus::Manifest::Entry::Nested),
           "owner" => e.owner,
           "format" => e.format,
           "derived" => derived,
-          "intake" => !e.intake_handler.nil?,
+          "intake" => e.is_a?(Textus::Manifest::Entry::Intake),
           "publish_to" => Array(e.publish_to),
-          "publish_each" => e.publish_each,
+          "publish_each" => e.respond_to?(:publish_each) ? e.publish_each : nil,
         }
       end
     end
 
     def self.hooks_for(store)
-      reg = store.registry
+      bus = store.bus
       sections = {}
-      Hooks::Registry::EVENTS.each do |event, spec|
+      Hooks::Bus::EVENTS.each do |event, spec|
         case spec[:mode]
         when :rpc
-          sections[event.to_s] = reg.rpc_names(event).map(&:to_s).sort
+          sections[event.to_s] = bus.rpc_names(event).map(&:to_s).sort
         when :pubsub
-          sections[event.to_s] = reg.pubsub_handlers(event).map { |h| h[:name].to_s }.sort
+          sections[event.to_s] = bus.pubsub_handlers(event).map { |h| h[:name].to_s }.sort
         end
       end
       sections