textus 0.51.0 → 0.53.0

data/lib/textus/{domain → manifest}/policy/retention.rb

@@ -1,9 +1,9 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       # Garbage collection (ADR 0093). A glob-matched rule slot: when an entry
       # ages past `ttl`, retire it. Destructive only — runs on the full
-      # `reconcile` pass, never on a write (ADR 0079's invariant). Orthogonal to
+      # `converge` pass, never on a write (ADR 0079's invariant). Orthogonal to
       # production (`source:`): an intake entry can re-pull hourly AND archive
       # after 90 days. `warn`/`refresh` are gone (refresh is implied by an
       # intake source; warn never fired after ADR 0089's pure-read get).
@@ -21,7 +21,7 @@ module Textus
           raise Textus::BadManifest.new("retention action must be one of #{ACTIONS.join("|")}, got #{raw["action"].inspect}")
         end
 
-        def ttl_seconds = Textus::Domain::Duration.seconds(@ttl)
+        def ttl_seconds = Textus::Core::Duration.seconds(@ttl)
         def destructive? = true
       end
     end

data/lib/textus/{domain → manifest}/policy/source.rb

@@ -1,17 +1,17 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       # An entry's data-acquisition declaration (ADR 0094). `source:` says HOW the
       # entry's data is acquired; rendering is a publish concern, so there are no
       # template/render fields here. `from` is the acquire + staleness axis:
-      #   from: project -> derived  (internal projection; observable -> rdeps staleness)
-      #   from: handler -> intake   (external fetch; unobservable -> ttl staleness)
-      #   from: command -> external (out-of-band runner; staleness only, textus never runs it)
-      # `on_write` (sync|async, default async) is the write-trigger strategy for
-      # observable (project) sources; meaningless for intake/command.
+      #   from: derive -> derived   (internal projection; observable -> rdeps staleness)
+      #   from: fetch -> intake     (external fetch; unobservable -> ttl staleness)
+      #   from: external -> external (out-of-band runner; staleness only, textus never runs it)
+      # Materialization is async-only (job-queue model): a write enqueues a
+      # `materialize` job, converged by a worker. There is no per-entry write
+      # trigger knob.
       class Source
-        FROMS      = %w[project handler command].freeze
-        STRATEGIES = %w[async sync].freeze
+        FROMS = %w[fetch derive external].freeze
 
         attr_reader :from, :handler, :config, :command, :sources
 
@@ -21,26 +21,25 @@ module Textus
             raise Textus::BadManifest.new("source.from must be one of #{FROMS.join("|")}, got #{raw["from"].inspect}")
           end
 
-          @on_write = (raw["on_write"] || "async").to_s
-          unless STRATEGIES.include?(@on_write)
-            raise Textus::BadManifest.new("source.on_write must be one of #{STRATEGIES.join("/")}, got #{@on_write.inspect}")
-          end
-
           @ttl = raw["ttl"]
           @projection = {}
 
           case @from
-          when "project" then init_project(raw)
-          when "handler" then init_handler(raw)
-          when "command" then init_command(raw)
+          when "fetch" then init_fetch(raw)
+          when "derive" then init_derive(raw)
+          when "external" then init_external(raw)
           end
         end
 
-        def kind        = @from == "handler" ? :intake : :derived
-        def external?   = @from == "command"
-        def projection? = @from == "project"
-        def sync?       = @on_write == "sync"
-        def ttl_seconds = @ttl.nil? ? nil : Textus::Domain::Duration.seconds(@ttl)
+        def kind
+          { "fetch" => :intake, "derive" => :derived, "external" => :external }.fetch(@from)
+        end
+
+        def fetch?      = @from == "fetch"
+        def derive?     = @from == "derive"
+        def external?   = @from == "external"
+        def projection? = derive?
+        def ttl_seconds = @ttl.nil? ? nil : Textus::Core::Duration.seconds(@ttl)
 
         # Flattened projection accessors (ADR 0094) — read directly off the source
         # block; nil when absent or not a projection source.
@@ -55,22 +54,22 @@ module Textus
 
         private
 
-        def init_project(raw)
+        def init_derive(raw)
           %w[select pluck sort_by transform].each { |f| @projection[f] = raw[f] if raw.key?(f) }
           return unless @projection["select"].nil? && @projection["transform"].nil?
 
-          raise Textus::BadManifest.new("source (from: project) requires `select:` and/or `transform:`")
+          raise Textus::BadManifest.new("source (from: derive) requires `select:` and/or `transform:`")
         end
 
-        def init_handler(raw)
+        def init_fetch(raw)
           @handler = raw["handler"] or
-            raise Textus::BadManifest.new("source (from: handler) requires a `handler:` field")
+            raise Textus::BadManifest.new("source (from: fetch) requires a `handler:` field")
           @config = raw["config"] || {}
         end
 
-        def init_command(raw)
+        def init_external(raw)
           @command = raw["command"] or
-            raise Textus::BadManifest.new("source (from: command) requires a `command:` field")
+            raise Textus::BadManifest.new("source (from: external) requires a `command:` field")
           @sources = raw["sources"] || []
         end
       end

data/lib/textus/manifest/policy.rb

@@ -1,23 +1,23 @@
 module Textus
   class Manifest
-    # Authority over zones and roles derived from a Manifest::Data snapshot.
+    # Authority over lanes and roles derived from a Manifest::Data snapshot.
     # Encapsulates the lookups previously living on Manifest itself
-    # (zone_writers, permission_for). Write authority is derived from
-    # capabilities × zone-kind (ADR 0030): each zone-kind requires one verb
-    # (Schema::KIND_REQUIRES_VERB) and a role may write a zone iff its caps
-    # include that verb (verb_for_zone, roles_with_capability). Derived /
+    # (lane_writers, permission_for). Write authority is derived from
+    # capabilities x lane-kind (ADR 0030): each lane-kind requires one verb
+    # (Schema::KIND_REQUIRES_VERB) and a role may write a lane iff its caps
+    # include that verb (verb_for_lane, roles_with_capability). Derived /
     # proposal-queue status is authoritative via the declared-kind family
-    # (declared_kind, derived_entry?, queue_zone?, queue_zone).
+    # (declared_kind, derived_entry?, queue_lane?, queue_lane).
     class Policy
       def initialize(data)
         @data = data
       end
 
-      # The capability a zone's kind requires to be written, or nil if the
-      # zone declares no kind. declared_kind returns a Symbol; the table is
+      # The capability a lane's kind requires to be written, or nil if the
+      # lane declares no kind. declared_kind returns a Symbol; the table is
       # keyed by String.
-      def verb_for_zone(zone_name)
-        kind = declared_kind(zone_name)
+      def verb_for_lane(lane_name)
+        kind = declared_kind(lane_name)
         kind && Schema::KIND_REQUIRES_VERB[kind.to_s]
       end
 
@@ -41,39 +41,24 @@ module Textus
         roles_with_capability(verb).first
       end
 
-      # The roles authorized to write `zone_name`: those holding the verb its
-      # kind requires. Raises on an undeclared zone.
-      def zone_writers(zone_name)
-        raise UsageError.new("undeclared zone '#{zone_name}'") unless @data.declared_zone_kinds.key?(zone_name)
-
-        roles_with_capability(verb_for_zone(zone_name))
-      end
-
-      def permission_for(zone_name)
-        Textus::Domain::Permission.new(
-          zone: zone_name,
-          writers: zone_writers(zone_name),
-        )
+      # The kind declared on a lane in the manifest, or nil if undeclared.
+      def declared_kind(lane_name)
+        @data.declared_lane_kinds[lane_name]
       end
 
-      # The kind declared on a zone in the manifest, or nil if undeclared.
-      def declared_kind(zone_name)
-        @data.declared_zone_kinds[zone_name]
+      # Lane names declaring `kind` (a Symbol), in manifest order. Lets callers
+      # (boot) name a kind's live lane instance(s) instead of hardcoding names.
+      def lanes_of_kind(kind)
+        @data.declared_lane_kinds.select { |_name, k| k == kind }.keys
       end
 
-      # Zone names declaring `kind` (a Symbol), in manifest order. Lets callers
-      # (boot) name a kind's live zone instance(s) instead of hardcoding names.
-      def zones_of_kind(kind)
-        @data.declared_zone_kinds.select { |_name, k| k == kind }.keys
+      # The single lane declaring `kind: queue`, or nil. Schema guarantees <=1.
+      def queue_lane
+        @data.declared_lane_kinds.key(:queue)
       end
 
-      # The single zone declaring `kind: queue`, or nil. Schema guarantees <=1.
-      def queue_zone
-        @data.declared_zone_kinds.key(:queue)
-      end
-
-      # ADR 0091: derived-ness is a property of the ENTRY, not its zone (one
-      # machine zone holds both intake and derived entries). Resolve the entry
+      # ADR 0091: derived-ness is a property of the ENTRY, not its lane (one
+      # machine lane holds both intake and derived entries). Resolve the entry
       # and ask it directly. Returns false if entries are not yet built
       # (validator phase during Data#initialize) — validators must not rely on
       # cross-entry state during construction.
@@ -84,24 +69,27 @@ module Textus
         entry.derived?
       end
 
-      # The single zone declaring kind: machine, or nil.
-      def machine_zone
-        @data.declared_zone_kinds.key(:machine)
+      # The single lane declaring kind: machine, or nil.
+      def machine_lane
+        @data.declared_lane_kinds.key(:machine)
       end
 
-      # A zone is a proposal queue iff it declares kind: queue.
-      def queue_zone?(zone_name)
-        declared_kind(zone_name) == :queue
+      # A lane is a proposal queue iff it declares kind: queue.
+      def queue_lane?(lane_name)
+        declared_kind(lane_name) == :queue
       end
 
-      # The zone a proposer role writes proposals into: the single zone that
+      # The lane a proposer role writes proposals into: the single lane that
       # declares kind: queue, when the role can write it. Returns nil if there
-      # is no queue zone or the role cannot write it.
-      def propose_zone_for(role)
+      # is no queue lane or the role cannot write it.
+      def propose_lane_for(role)
         return nil if role.nil?
 
-        q = queue_zone
-        return nil unless q && zone_writers(q).include?(role)
+        q = queue_lane
+        return nil unless q
+
+        q_verb = verb_for_lane(q)
+        return nil unless roles_with_capability(q_verb).include?(role)
 
         q
       end

data/lib/textus/manifest/resolver.rb

@@ -54,7 +54,8 @@ module Textus
           raise UnknownKey.new(key, suggestions: suggestions_for(key)) unless nested_entry?(entry)
 
           primary_ext = Textus::Entry.for_format(entry.format).extensions.first
-          path = File.join(@data.root, "zones", entry.path, *remaining) + primary_ext
+          base = Textus::Key::Path.normalize_relative_path(entry.path)
+          path = File.join(@data.root, base, *remaining) + primary_ext
           Resolution.new(entry: entry, path: path, remaining: remaining)
         end
       end
@@ -73,7 +74,7 @@ module Textus
         # addressable store keys in the public `list` surface.
         return [] if entry.publish_mode.keyless? && !include_keyless
 
-        base = File.join(@data.root, "zones", entry.path)
+        base = File.join(@data.root, Textus::Key::Path.normalize_relative_path(entry.path))
         return [] unless File.directory?(base)
 
         Dir.glob(File.join(base, nested_glob(entry.format)))

data/lib/textus/manifest/rules.rb

@@ -22,7 +22,7 @@ module Textus
       def for(key)
         slots = PICK_FIELDS.to_h { |f| [f, []] }
         @blocks.each do |b|
-          next unless Textus::Domain::Policy::Matcher.matches?(b.match, key)
+          next unless Textus::Manifest::Policy::Matcher.matches?(b.match, key)
 
           slots.each_key { |slot| slots[slot] << b if b.public_send(slot) }
         end
@@ -30,7 +30,7 @@ module Textus
       end
 
       def explain(key)
-        @blocks.select { |b| Textus::Domain::Policy::Matcher.matches?(b.match, key) }
+        @blocks.select { |b| Textus::Manifest::Policy::Matcher.matches?(b.match, key) }
       end
 
       private
@@ -39,7 +39,7 @@ module Textus
         return nil if blocks.empty?
 
         globs = blocks.map(&:match)
-        winning = Textus::Domain::Policy::Matcher.pick_most_specific(globs, key: key)
+        winning = Textus::Manifest::Policy::Matcher.pick_most_specific(globs, key: key)
         blocks.find { |b| b.match == winning }&.public_send(slot)
       end
 
@@ -57,7 +57,7 @@ module Textus
 
         # One dispatch over the registry, replacing the four bespoke parse_*
         # methods. :deferred carries the raw Hash after a shape check (its
-        # contents validate later — guard predicates at GuardFactory build time,
+        # contents validate later — guard predicates at Dispatch::Auth check time,
         # ADR 0031); :immediate instantiates the policy class now. :tagged passes
         # the raw Hash straight to a policy class that is a tagged union and
         # dispatches on its discriminator field (e.g. upkeep's on:). A mapping

data/lib/textus/manifest/schema/keys.rb

@@ -4,11 +4,11 @@ module Textus
       # The manifest's key whitelists and the rule-field registry — the schema's
       # data tables (ADR 0109; the vocabulary lives in Schema::Vocabulary).
       module Keys
-        ROOT_KEYS  = %w[version roles zones entries rules audit].freeze
+        ROOT_KEYS  = %w[version roles lanes entries rules audit].freeze
         ROLE_KEYS  = %w[name can].freeze
-        ZONE_KEYS  = %w[name kind owner desc].freeze
+        LANE_KEYS  = %w[name kind owner desc].freeze
         ENTRY_KEYS = %w[
-          key path zone kind schema owner nested format
+          key path lane kind schema owner nested format
           source publish
           events ignore tracked
         ].freeze
@@ -23,7 +23,7 @@ module Textus
         # `inject_boot`/`provenance` fields are kept here so the schema walk can
         # still emit the migration hint rather than a bare "unknown key".
         SOURCE_KEYS = %w[
-          from handler config template project command sources ttl on_write inject_boot provenance
+          from handler config template project command sources ttl inject_boot provenance
           select pluck sort_by transform
         ].freeze
         # ADR 0093: rule-level GC slot. drop/archive only (refresh gone).
@@ -40,12 +40,11 @@ module Textus
         #     (in_rule_list / in_rule_explain)
         #
         # Per field:
-        #   yaml_key     manifest key (handler_allowlist's intake_ prefix
-        #                disambiguates from entry-level intake:, ADR 0059)
-        #   policy_class the Domain::Policy backing the field (nil = raw value)
+        #   yaml_key     manifest key used in a rule block
+        #   policy_class the Manifest::Policy backing the field (nil = raw value)
         #   validation   :immediate (instantiate the policy at parse, surfacing
         #                shape errors eagerly), :deferred (shape-check + carry
-        #                the raw Hash; guard predicates validate at GuardFactory
+        #                the raw Hash; guard predicates validate at Dispatch::Auth
         #                build time, ADR 0031), or :tagged (pass the raw Hash to a
         #                tagged-union policy that dispatches on its discriminator
         #                field, e.g. upkeep's on:)
@@ -61,9 +60,9 @@ module Textus
         # Key order here fixes the order of RULE_KEYS (after match), the slots,
         # the RuleSet members, and the doctor SLOTS.
         FIELD_REGISTRY = {
-          handler_allowlist: {
-            yaml_key: "intake_handler_allowlist",
-            policy_class: Textus::Domain::Policy::HandlerAllowlist,
+          handler_permit: {
+            yaml_key: "handler_permit",
+            policy_class: Textus::Manifest::Policy::HandlerPermit,
             validation: :immediate, sub_keys: nil, arg_key: :handlers,
             in_pick: true, in_ambiguity: true,
             in_rule_list: true, in_rule_explain: %i[detail]
@@ -77,11 +76,18 @@ module Textus
           },
           retention: {
             yaml_key: "retention",
-            policy_class: Textus::Domain::Policy::Retention,
+            policy_class: Textus::Manifest::Policy::Retention,
             validation: :tagged, sub_keys: RETENTION_KEYS, arg_key: nil,
             in_pick: true, in_ambiguity: true,
             in_rule_list: true, in_rule_explain: %i[lean detail]
           },
+          react: {
+            yaml_key: "react",
+            policy_class: Textus::Manifest::Policy::React,
+            validation: :immediate, sub_keys: nil, arg_key: :raw,
+            in_pick: true, in_ambiguity: true,
+            in_rule_list: true, in_rule_explain: %i[lean detail]
+          },
         }.freeze
 
         RULE_KEYS = (["match"] + FIELD_REGISTRY.values.map { |m| m[:yaml_key] }).freeze

data/lib/textus/manifest/schema/validator.rb

@@ -14,34 +14,36 @@ module Textus
           raise BadManifest.new("manifest must be a hash") unless raw.is_a?(Hash)
 
           walk(raw, ROOT_KEYS, "$")
+          raise BadManifest.new("manifest must declare lanes:") if Array(raw["lanes"]).empty?
+
           validate_roles!(raw["roles"])
-          validate_zones!(raw["zones"])
+          validate_lanes!(raw["lanes"])
           validate_entries!(raw["entries"])
-          validate_owners!(raw["zones"], raw["entries"])
+          validate_owners!(raw["lanes"], raw["entries"])
           validate_rules!(raw["rules"])
           walk(raw["audit"], AUDIT_KEYS, "$.audit") if raw["audit"].is_a?(Hash)
           validate_single_queue!(raw)
           validate_single_machine!(raw)
-          validate_zone_kind_consistency!(raw)
+          validate_lane_kind_consistency!(raw)
         end
 
-        def validate_zones!(zones)
-          Array(zones).each_with_index do |z, i|
-            walk(z, ZONE_KEYS, "$.zones[#{i}]")
+        def validate_lanes!(lanes)
+          Array(lanes).each_with_index do |z, i|
+            walk(z, LANE_KEYS, "$.lanes[#{i}]")
             if z["kind"].nil?
-              raise BadManifest.new("zone '#{z["name"]}' at '$.zones[#{i}]' must declare a kind (one of: #{ZONE_KINDS.join(", ")})")
+              raise BadManifest.new("lane '#{z["name"]}' at '$.lanes[#{i}]' must declare a kind (one of: #{LANE_KINDS.join(", ")})")
             end
-            next if ZONE_KINDS.include?(z["kind"])
+            next if LANE_KINDS.include?(z["kind"])
 
             if %w[quarantine derived].include?(z["kind"])
               raise BadManifest.new(
-                "zone kind '#{z["kind"]}' at '$.zones[#{i}]' was folded into 'machine' (ADR 0091) — " \
+                "lane kind '#{z["kind"]}' at '$.lanes[#{i}]' was folded into 'machine' (ADR 0091) — " \
                 "use `kind: machine`",
               )
             end
 
             raise BadManifest.new(
-              "unknown zone kind '#{z["kind"]}' at '$.zones[#{i}]' (known: #{ZONE_KINDS.join(", ")})",
+              "unknown lane kind '#{z["kind"]}' at '$.lanes[#{i}]' (known: #{LANE_KINDS.join(", ")})",
             )
           end
         end
@@ -168,7 +170,7 @@ module Textus
           hints = {
             "lifecycle" => "age GC moved to the `retention:` rule ({ ttl, action: drop|archive }); " \
                            "intake cadence to the entry's `source: { ttl }`",
-            "materialize" => "moved to the entry's `source: { on_write: sync|async }`",
+            "materialize" => "removed — materialization is automatic (a write enqueues a job; run `drain`)",
           }
           hints.each do |old, hint|
             next unless rule.key?(old)
@@ -194,10 +196,10 @@ module Textus
             Array(r["can"]).each do |verb|
               next if CAPABILITIES.include?(verb)
 
-              # The quarantine capability folded into reconcile (ADR 0090); a
+              # The quarantine capability folded into the converge capability (ADR 0090); a
               # manifest still naming the old quarantine capability (`ingest`, or
               # legacy `fetch`) gets a pointed hint rather than a bare error.
-              hint = %w[ingest fetch].include?(verb) ? " — the quarantine capability folded into 'reconcile' (ADR 0090)" : ""
+              hint = %w[ingest fetch].include?(verb) ? " — the quarantine capability folded into 'converge' (ADR 0090)" : ""
               raise BadManifest.new(
                 "unknown capability '#{verb}' for role '#{name}' at '#{path}' " \
                 "(known: #{CAPABILITIES.join(", ")})#{hint}",
@@ -217,9 +219,9 @@ module Textus
         # (ADR 0045 D1) so attribution can't bypass the closed-name guarantee.
         # Applies to both zone owners and entry owners; owner is optional, so a
         # nil owner is not an error.
-        def validate_owners!(zones, entries)
-          Array(zones).each_with_index do |z, i|
-            check_owner!(z["owner"], "$.zones[#{i}]")
+        def validate_owners!(lanes, entries)
+          Array(lanes).each_with_index do |z, i|
+            check_owner!(z["owner"], "$.lanes[#{i}]")
           end
           Array(entries).each_with_index do |e, i|
             check_owner!(e["owner"], "$.entries[#{i}]")
@@ -265,20 +267,20 @@ module Textus
         end
 
         def validate_single_queue!(raw)
-          queues = Array(raw["zones"]).select { |z| z["kind"] == "queue" }.map { |z| z["name"] }
+          queues = Array(raw["lanes"]).select { |z| z["kind"] == "queue" }.map { |z| z["name"] }
           return if queues.size <= 1
 
           raise BadManifest.new(
-            "at most one zone may declare kind: queue (found: #{queues.join(", ")})",
+            "at most one lane may declare kind: queue (found: #{queues.join(", ")})",
           )
         end
 
         def validate_single_machine!(raw)
-          machines = Array(raw["zones"]).select { |z| z["kind"] == "machine" }.map { |z| z["name"] }
+          machines = Array(raw["lanes"]).select { |z| z["kind"] == "machine" }.map { |z| z["name"] }
           return if machines.size <= 1
 
           raise BadManifest.new(
-            "at most one zone may declare kind: machine (found: #{machines.join(", ")})",
+            "at most one lane may declare kind: machine (found: #{machines.join(", ")})",
           )
         end
 
@@ -300,20 +302,20 @@ module Textus
           end
         end
 
-        # Write authority is derived from capabilities (ADR 0030): a zone of a
+        # Write authority is derived from capabilities (ADR 0030): a lane of a
         # given kind can only be written by a role that holds the kind's required
-        # verb. Reject a manifest declaring a zone whose required verb is held by
+        # verb. Reject a manifest declaring a lane whose required verb is held by
         # no role. Capabilities.resolve returns the defaults when `roles:` is nil,
         # so the capability union is all four verbs and every kind is satisfied.
-        def validate_zone_kind_consistency!(raw)
+        def validate_lane_kind_consistency!(raw)
           held = Capabilities.resolve(raw["roles"]).values.flatten.uniq
 
-          Array(raw["zones"]).each_with_index do |z, i|
+          Array(raw["lanes"]).each_with_index do |z, i|
             verb = KIND_REQUIRES_VERB[z["kind"]]
             next if verb.nil? || held.include?(verb)
 
             raise BadManifest.new(
-              "zone '#{z["name"]}' (#{z["kind"]}) at '$.zones[#{i}]' " \
+              "lane '#{z["name"]}' (#{z["kind"]}) at '$.lanes[#{i}]' " \
               "needs a role with capability '#{verb}'; none declared",
             )
           end

data/lib/textus/manifest/schema/vocabulary.rb

@@ -5,17 +5,17 @@ module Textus
       # 0034; the quarantine + derived ZONE-KINDS folded into one `machine` kind
       # in ADR 0091). Each kind pairs with the capability that authorizes
       # originating bytes in it. ONE source of truth; the derived constants below
-      # cannot drift. A BIJECTION again (0090 had two kinds → reconcile; 0091
+      # cannot drift. A BIJECTION again (0090 had two kinds → the converge capability; 0091
       # collapses them, so kind ↔ capability is 1:1).
       module Vocabulary
         LANES = {
           "canon" => "author",
           "workspace" => "keep",
-          "machine" => "reconcile",
+          "machine" => "converge",
           "queue" => "propose",
         }.freeze
 
-        ZONE_KINDS         = LANES.keys.freeze
+        LANE_KINDS         = LANES.keys.freeze
         CAPABILITIES       = LANES.values.uniq.freeze
         KIND_REQUIRES_VERB = LANES
       end

data/lib/textus/manifest/schema.rb

@@ -7,13 +7,13 @@ module Textus
     module Schema
       # Re-export the vocabulary.
       LANES              = Vocabulary::LANES
-      ZONE_KINDS         = Vocabulary::ZONE_KINDS
+      LANE_KINDS         = Vocabulary::LANE_KINDS
       CAPABILITIES       = Vocabulary::CAPABILITIES
       KIND_REQUIRES_VERB = Vocabulary::KIND_REQUIRES_VERB
       # Re-export the keys + registry.
       ROOT_KEYS             = Keys::ROOT_KEYS
       ROLE_KEYS             = Keys::ROLE_KEYS
-      ZONE_KEYS             = Keys::ZONE_KEYS
+      LANE_KEYS             = Keys::LANE_KEYS
       ENTRY_KEYS            = Keys::ENTRY_KEYS
       PUBLISH_KEYS          = Keys::PUBLISH_KEYS
       SOURCE_KEYS           = Keys::SOURCE_KEYS

data/lib/textus/manifest.rb

@@ -6,8 +6,8 @@ module Textus
   #
   #   * data     — frozen value: raw, root, zones, entries, audit_config, role_caps
   #   * resolver — resolves keys → entry + path
-  #   * policy   — zone/role authority (zone_writers, declared_kind, derived_entry?,
-  #     queue_zone?, permission_for, …)
+  #   * policy   — zone/role authority (lane_writers, declared_kind, derived_entry?,
+  #     queue_lane?, permission_for, …)
   #   * rules    — match-block rule engine (lifecycle, handler allowlist, materialize, …)
   #
   # Use `manifest.data.entries`, `manifest.policy.declared_kind(z)`, etc.

data/lib/textus/{produce → pipeline}/acquire/handler.rb

@@ -1,12 +1,12 @@
 require "timeout"
 
 module Textus
-  module Produce
+  module Pipeline
     module Acquire
       # Invokes a :resolve_handler hook handler by name under a timeout — the single
       # home for "call the intake handler under a deadline" (ADR 0048 D1). Shared by
       # Produce::Acquire::Intake (the internal ingest mechanism — no public verb since ADR 0079)
-      # as driven by the `reconcile` sweep and `textus hook run` (ADR 0089 made
+      # as driven by the converge sweep (drain/serve) and `textus hook run` (ADR 0089 made
       # ingest system-pushed; there is no read or put trigger).
       # Always passes a Container as `caps:` so the hook contract (ADR 0027) is
       # uniform across every entry point. Maps Timeout::Error to a UsageError;
@@ -18,7 +18,7 @@ module Textus
 
         def invoke(caps:, handler:, config:, args:, label:, timeout: FETCH_TIMEOUT_SECONDS)
           Timeout.timeout(timeout) do
-            caps.rpc.invoke(:resolve_handler, handler, caps: caps, config: config, args: args)
+            caps.steps.invoke(:fetch, handler, caps: caps, config: config, args: args)
           end
         rescue Timeout::Error
           raise Textus::UsageError.new("#{label} '#{handler}' exceeded #{timeout}s timeout")