textus 0.51.0 → 0.53.0

data/lib/textus/init.rb

@@ -10,32 +10,32 @@ module Textus
       roles:
         - { name: human,      can: [author, propose] }
         - { name: agent,      can: [propose, keep] }
-        - { name: automation, can: [reconcile] }
-      zones:
+        - { name: automation, can: [converge] }
+      lanes:
         - { name: knowledge, kind: canon,     desc: "the maintained source of truth (identity.* lives here)" }
         - { name: notebook,  kind: workspace, owner: agent, desc: "the agent's own durable working notes" }
         - { name: proposals, kind: queue,     desc: "changes awaiting your accept" }
         - { name: artifacts, kind: machine,   desc: "machine-maintained: external inputs (artifacts.feeds.*) + computed outputs (artifacts.derived.*)" }
       entries:
-        - { key: knowledge.identity, path: knowledge/identity.md, zone: knowledge, schema: null, owner: human:self, kind: leaf }
-        - { key: knowledge.notes,    path: knowledge/notes,       zone: knowledge, schema: null, owner: human:self, nested: true, kind: nested }
-        - { key: notebook.notes,     path: notebook/notes,        zone: notebook,  schema: null, owner: agent:self, nested: true, kind: nested }
-        - { key: proposals.notes,    path: proposals/notes,       zone: proposals, schema: null, owner: agent:self, nested: true, kind: nested }
-        # A per-host snapshot, refreshed from its declared intake by `textus reconcile` (scheduled, or on demand).
+        - { key: knowledge.identity, path: data/knowledge/identity.md, lane: knowledge, schema: null, owner: human:self, kind: leaf }
+        - { key: knowledge.notes,    path: data/knowledge/notes,       lane: knowledge, schema: null, owner: human:self, nested: true, kind: nested }
+        - { key: notebook.notes,     path: data/notebook/notes,        lane: notebook,  schema: null, owner: agent:self, nested: true, kind: nested }
+        - { key: proposals.notes,    path: data/proposals/notes,       lane: proposals, schema: null, owner: agent:self, nested: true, kind: nested }
+        # A per-host snapshot, refreshed from its declared intake by `textus drain` (scheduled, or on demand).
         # Nested so it grows to a fleet — add artifacts.feeds.machines.<host> leaves over SSH
         # (see docs/cookbook/environment-scan.md) without renaming. tracked:false →
         # gitignored (machine info can be sensitive/noisy) but still protocol-readable
         # via `textus get artifacts.feeds.machines.local`. Delete to opt out. (ADR 0043)
         - key: artifacts.feeds.machines
-          path: artifacts/feeds/machines
-          zone: artifacts
+          path: data/artifacts/feeds/machines
+          lane: artifacts
           format: yaml
           nested: true
           tracked: false
           kind: produced
           source:
-            from: handler
-            handler: machines
+            from: fetch
+            handler: machine-intake
             ttl: 1h # cadence on a long-running server
             config:
               machines:
@@ -43,59 +43,42 @@ module Textus
       rules: []
     YAML
 
-    HOOKS_README = <<~MD
-      # Hooks
+    STEPS_README = <<~MD
+      # Steps
 
-      Drop one Ruby file per hook. All hooks register through one DSL.
-      Files anywhere under `.textus/hooks/` (including subdirectories) are loaded at
-      startup in alphabetical order by full path. Subdirectory names are organizational
-      only — the registered event and name come from the DSL call, not the file path.
+      Drop one Ruby file per step. Steps are discovered by convention.
+      Files under `.textus/steps/<kind>/<name>.rb` are loaded at
+      startup and registered.
 
-      ## DSL
+      ## Conventions
 
-      ```ruby
-      Textus.hook do |reg|
-        reg.on(:resolve_handler, :my_source) do |config:, args:, **|
-          { _meta: { "last_fetched_at" => Time.now.utc.iso8601 }, body: "…" }
-        end
+      The directory name (`<kind>`) must be one of:
+      - `fetch`: Acquires data from outside the store.
+      - `transform`: Reshapes projection rows.
+      - `validate`: Validates data before writing.
+      - `observe`: Listens to store events.
 
-        reg.on(:transform_rows, :my_source) { |rows:, **| rows.map { |r| r.merge(processed: true) } }
-        reg.on(:validate,       :my_check)  { |caps:, **| [] }
-        reg.on(:entry_written,      :my_listener, keys: ["knowledge.*"]) { |key:, envelope:, **| }
+      The filename (`<name>.rb`) defines the step name. The class defined
+      in the file must be a subclass of `Textus::Step::<Kind>` (e.g.
+      `Textus::Step::Fetch`) and be wrapped in the `Textus::Step` module.
 
-        # Run a side-effect every time textus writes a file to your repo:
-        reg.on(:entry_published, :notify) do |key:, target:, **|
-          warn "wrote \#{target} (from \#{key})"
+      ## Example
+
+      ```ruby
+      module Textus
+        module Step
+          class MyFetch < Fetch
+            def call(config:, args:, caps:, **)
+              { content: { "foo" => "bar" } }
+            end
+          end
         end
       end
       ```
 
-      The intake handler above is paired with a manifest entry whose
-      `source:` block declares the handler and its refresh cadence
-      (`ttl`). Age GC (drop/archive) lives in a top-level `retention:`
-      rule, not on the entry:
-
-      ```yaml
-      entries:
-        - key: artifacts.feeds.foo
-          kind: produced
-          path: artifacts/feeds/foo.md
-          zone: artifacts
-          source:
-            from: handler
-            handler: my_source
-            ttl: 10m        # refresh cadence for this intake
-
-      rules:
-        - match: artifacts.feeds.foo
-          retention:
-            ttl: 30d
-            action: archive   # drop | archive (age GC of stored rows)
-      ```
-
-      Events: :resolve_handler, :transform_rows, :validate (rpc — return value used)
+      Events: :fetch, :transform, :validate (rpc — return value used)
               :entry_written, :entry_deleted, :entry_fetched, :entry_renamed,
-              :entry_produced, :produce_failed, :reconcile_failed,
+              :entry_produced, :produce_failed,
               :proposal_accepted, :proposal_rejected,
               :entry_published, :store_loaded, :session_opened,
               :entry_fetch_started, :entry_fetch_failed (pub-sub — return discarded)
@@ -104,50 +87,83 @@ module Textus
     MD
 
     AGENT_ENTRIES = <<~YAML.gsub(/^/, "  ")
-      # --with-agent profile: project facts + runbooks feed the orientation
-      # projection below, which `textus reconcile` renders to CLAUDE.md/AGENTS.md.
-      - { key: knowledge.project, path: knowledge/project.md, zone: knowledge, schema: project, owner: human:self, kind: leaf }
-      - { key: knowledge.runbooks, path: knowledge/runbooks, zone: knowledge, schema: runbook, owner: human:self, nested: true, kind: nested }
+      - { key: knowledge.project, path: data/knowledge/project.md, lane: knowledge, schema: project, owner: human:self, kind: leaf }
+      - { key: knowledge.runbooks, path: data/knowledge/runbooks, lane: knowledge, schema: runbook, owner: human:self, nested: true, kind: nested }
       - key: artifacts.derived.orientation
-        path: artifacts/derived/orientation.json
-        zone: artifacts
+        path: data/artifacts/derived/orientation.json
+        lane: artifacts
         publish:
         - { to: CLAUDE.md, template: orientation.mustache, inject_boot: true }
         - { to: AGENTS.md, template: orientation.mustache, inject_boot: true }
         source:
-          from: project
+          from: derive
           select:
           - knowledge.project
           - knowledge.runbooks
-          transform: orientation_reducer
+          transform: orientation
         kind: produced
     YAML
 
     def self.run(target_root, with_agent: false)
+      check_target!(target_root)
+      scaffold_dir = File.expand_path("init/templates", __dir__)
+      create_directories(target_root)
+      write_steps_readme(target_root, scaffold_dir)
+      write_manifest(target_root, with_agent:)
+      mcp_status = scaffold_agent(target_root, scaffold_dir, with_agent:)
+      setup_state_dirs(target_root)
+      write_gitignore(target_root)
+      build_result(target_root, with_agent:, mcp_status:)
+    end
+
+    def self.check_target!(target_root)
       raise UsageError.new(".textus/ already exists at #{target_root}") if File.directory?(target_root)
+    end
 
+    def self.create_directories(target_root)
       FileUtils.mkdir_p(File.join(target_root, "schemas"))
       FileUtils.mkdir_p(File.join(target_root, "templates"))
-      FileUtils.mkdir_p(File.join(target_root, "hooks"))
+      FileUtils.mkdir_p(File.join(target_root, "steps/fetch"))
+      FileUtils.mkdir_p(File.join(target_root, "steps/transform"))
+      FileUtils.mkdir_p(File.join(target_root, "steps/validate"))
+      FileUtils.mkdir_p(File.join(target_root, "steps/observe"))
       ZONES.each do |z|
-        dir = File.join(target_root, "zones", z)
+        dir = File.join(target_root, "data", z)
         FileUtils.mkdir_p(dir)
         File.write(File.join(dir, ".gitkeep"), "")
       end
-      File.write(File.join(target_root, "hooks", "README.md"), HOOKS_README)
-      scaffold_dir = File.expand_path("init/templates", __dir__)
-      File.write(File.join(target_root, "hooks", "machine_intake.rb"),
-                 File.read(File.join(scaffold_dir, "machine_intake.rb")))
+    end
+
+    def self.write_steps_readme(target_root, scaffold_dir)
+      File.write(File.join(target_root, "steps/README.md"), STEPS_README)
+      File.write(
+        File.join(target_root, "steps/fetch/machine-intake.rb"),
+        File.read(File.join(scaffold_dir, "machine_intake.rb")),
+      )
+    end
+
+    def self.write_manifest(target_root, with_agent:)
       File.write(File.join(target_root, "manifest.yaml"), manifest_yaml(with_agent: with_agent))
-      mcp_status = nil
-      if with_agent
-        scaffold_agent_profile(target_root, scaffold_dir)
-        mcp_status = write_mcp_config(target_root, scaffold_dir)
-      end
+    end
+
+    def self.scaffold_agent(target_root, scaffold_dir, with_agent:)
+      return nil unless with_agent
+
+      scaffold_agent_profile(target_root, scaffold_dir)
+      write_mcp_config(target_root, scaffold_dir)
+    end
+
+    def self.setup_state_dirs(target_root)
       FileUtils.mkdir_p(Textus::Layout.audit_dir(target_root))
       FileUtils.mkdir_p(Textus::Layout.state(target_root))
       FileUtils.mkdir_p(Textus::Layout.locks(target_root))
+    end
+
+    def self.write_gitignore(target_root)
       File.write(File.join(target_root, ".gitignore"), derived_gitignore(target_root))
+    end
+
+    def self.build_result(target_root, with_agent:, mcp_status:)
       result = { "protocol" => PROTOCOL, "initialized" => target_root, "profile" => with_agent ? "agent" : "default" }
       result["mcp_config"] = mcp_status if with_agent
       result
@@ -168,7 +184,7 @@ module Textus
         "project.schema.yaml" => File.join("schemas", "project.yaml"),
         "runbook.schema.yaml" => File.join("schemas", "runbook.yaml"),
         "orientation.mustache" => File.join("templates", "orientation.mustache"),
-        "orientation_reducer.rb" => File.join("hooks", "orientation_reducer.rb"),
+        "orientation_reducer.rb" => File.join("steps/transform", "orientation.rb"),
       }.each do |src, dest|
         File.write(File.join(target_root, dest), File.read(File.join(scaffold_dir, src)))
       end
@@ -193,8 +209,9 @@ module Textus
       manifest = Textus::Manifest.load(target_root)
       root = Pathname.new(target_root)
       untracked = manifest.data.entries.reject(&:tracked?).map do |e|
-        if e.nested? # a whole subtree of leaf files (artifacts.feeds.machines.* → zones/artifacts/feeds/machines/)
-          "#{File.join("zones", e.path)}/"
+        if e.nested? # a whole subtree of leaf files (artifacts.feeds.machines.* → data/artifacts/feeds/machines/)
+          rel = e.path.start_with?("data/") ? e.path : File.join("data", e.path)
+          "#{rel}/"
         else
           Pathname.new(Textus::Key::Path.resolve(manifest.data, e)).relative_path_from(root).to_s
         end

data/lib/textus/key/path.rb

@@ -10,12 +10,19 @@ module Textus
       # `manifest.data`.
       def self.resolve(data, mentry)
         primary_ext = Entry.for_format(mentry.format).extensions.first
+        rel_path = normalize_relative_path(mentry.path)
         if File.extname(mentry.path) == ""
-          File.join(data.root, "zones", mentry.path + primary_ext)
+          File.join(data.root, rel_path + primary_ext)
         else
-          File.join(data.root, "zones", mentry.path)
+          File.join(data.root, rel_path)
         end
       end
+
+      def self.normalize_relative_path(path)
+        return path if path.start_with?("data/")
+
+        File.join("data", path)
+      end
     end
   end
 end

data/lib/textus/layout.rb

@@ -4,6 +4,15 @@ module Textus
   # tracked/disposable boundary is a directory boundary. ADR 0038.
   module Layout
     RUN = ".run"
+    DATA = "data"
+
+    def self.data(root)
+      File.join(root, DATA)
+    end
+
+    def self.data_lane(root, lane_name)
+      File.join(data(root), lane_name)
+    end
 
     def self.run(root)
       File.join(root, RUN)
@@ -25,6 +34,18 @@ module Textus
       File.join(run(root), "build.lock")
     end
 
+    def self.watcher_lock(root)
+      File.join(run(root), "watcher.lock")
+    end
+
+    def self.queue(root)
+      File.join(run(root), "queue")
+    end
+
+    def self.queue_state(root, state)
+      File.join(queue(root), state.to_s)
+    end
+
     def self.audit_dir(root)
       File.join(run(root), "audit")
     end

data/lib/textus/manifest/capabilities.rb

@@ -13,7 +13,7 @@ module Textus
       DEFAULT_MAPPING = {
         Textus::Role::HUMAN => %w[author propose].freeze,
         Textus::Role::AGENT => %w[propose].freeze,
-        Textus::Role::AUTOMATION => %w[reconcile].freeze,
+        Textus::Role::AUTOMATION => %w[converge].freeze,
       }.freeze
 
       # Returns { role_name => [verbs] }. When `roles:` is declared we use

data/lib/textus/manifest/data.rb

@@ -5,15 +5,16 @@ module Textus
   class Manifest
     # Immutable, parsed view of a manifest YAML document.
     #
-    # Holds raw structural data (zones, entries, audit_config, role_caps)
-    # but no behaviour beyond accessors. Behaviour (zone authority, key
+    # Holds raw structural data (lanes, entries, audit_config, role_caps)
+    # but no behaviour beyond accessors. Behaviour (lane authority, key
     # resolution, rules) lives on Manifest::Policy / Resolver / Rules.
     class Data
       AUDIT_DEFAULTS = { max_size: 10_485_760, keep: 5 }.freeze
+      WORKER_DEFAULTS = { pool: 4, poll: 5, lease_ttl: 60, max_attempts: 3 }.freeze
 
-      attr_reader :raw, :root, :entries, :declared_zone_kinds,
-                  :zone_descs, :zone_owners,
-                  :audit_config, :role_caps, :policy
+      attr_reader :raw, :root, :entries, :declared_lane_kinds,
+                  :lane_descs, :lane_owners,
+                  :audit_config, :worker_config, :role_caps, :policy
 
       def self.validate_key!(key)
         raise UsageError.new("empty key") if key.nil? || key.empty?
@@ -26,7 +27,7 @@ module Textus
       def validate_key!(key) = self.class.validate_key!(key)
 
       def self.parse(raw, root:)
-        raise BadFrontmatter.new(File.join(root.to_s, "manifest.yaml"), "manifest must declare zones:") if Array(raw["zones"]).empty?
+        raise BadFrontmatter.new(File.join(root.to_s, "manifest.yaml"), "manifest must declare lanes:") if Array(raw["lanes"]).empty?
 
         Schema.validate!(raw)
         new(raw: raw, root: root)
@@ -35,18 +36,19 @@ module Textus
       def initialize(raw:, root:)
         @raw = raw
         @root = root
-        # Write authority is derived from capabilities × zone-kind (ADR 0030),
-        # not a per-zone writer list. "Which zones are declared" lives in the
-        # one kind-keyed map below (declared_zone_kinds); membership checks by
-        # read-side callers (boot, maintenance/zone_mv) use its keyset (ADR 0034).
-        @declared_zone_kinds = Array(raw["zones"]).to_h do |z|
+        # Write authority is derived from capabilities × lane-kind (ADR 0030),
+        # not a per-lane writer list. "Which lanes are declared" lives in the
+        # one kind-keyed map below (declared_lane_kinds); membership checks by
+        # read-side callers (boot, maintenance/data_mv) use its keyset (ADR 0034).
+        @declared_lane_kinds = Array(raw["lanes"]).to_h do |z|
           [z["name"], z["kind"]&.to_sym]
         end
-        @zone_descs  = Array(raw["zones"]).to_h { |z| [z["name"], z["desc"]] }
-        # Only zones that actually declare an owner — keep nil-tombstones out so a
-        # future `zone_owners.key?(name)` means "owner declared", not "zone exists".
-        @zone_owners = Array(raw["zones"]).to_h { |z| [z["name"], z["owner"]] }.compact
+        @lane_descs  = Array(raw["lanes"]).to_h { |z| [z["name"], z["desc"]] }
+        # Only lanes that actually declare an owner — keep nil-tombstones out so a
+        # future `lane_owners.key?(name)` means "owner declared", not "lane exists".
+        @lane_owners = Array(raw["lanes"]).to_h { |z| [z["name"], z["owner"]] }.compact
         @audit_config = build_audit_config(raw)
+        @worker_config = build_worker_config(raw)
         @role_caps = Capabilities.resolve(raw["roles"])
         # Policy is constructed before entries because Entry validators
         # use the entry's own `derived?` and similar helpers that call into
@@ -67,6 +69,19 @@ module Textus
         }.freeze
       end
 
+      # Worker/queue tunables (ADR: job-queue execution model). All optional;
+      # the daemon (serve) and batch drain read these, falling back to defaults
+      # so a manifest with no `worker:` block runs the queue out of the box.
+      def build_worker_config(raw)
+        w = raw["worker"] || {}
+        {
+          pool: w["pool"] || WORKER_DEFAULTS[:pool],
+          poll: w["poll"] || WORKER_DEFAULTS[:poll],
+          lease_ttl: w["lease_ttl"] || WORKER_DEFAULTS[:lease_ttl],
+          max_attempts: w["max_attempts"] || WORKER_DEFAULTS[:max_attempts],
+        }.freeze
+      end
+
       def build_entries(raw)
         Array(raw["entries"]).map do |e|
           entry = Manifest::Entry::Parser.call(e)

data/lib/textus/manifest/entry/base.rb

@@ -2,14 +2,14 @@ module Textus
   class Manifest
     class Entry
       class Base < Entry
-        attr_reader :raw, :key, :path, :zone, :schema, :owner, :format, :publish_targets
+        attr_reader :raw, :key, :path, :lane, :schema, :owner, :format, :publish_targets
 
         # rubocop:disable Metrics/ParameterLists, Lint/MissingSuper
-        def initialize(raw:, key:, path:, zone:, schema:, owner:, format:, publish_targets: [])
+        def initialize(raw:, key:, path:, lane:, schema:, owner:, format:, publish_targets: [])
           @raw = raw
           @key = key
           @path = path
-          @zone = zone
+          @lane = lane
           @schema = schema
           @owner = owner
           @format = format
@@ -17,13 +17,14 @@ module Textus
         end
         # rubocop:enable Metrics/ParameterLists, Lint/MissingSuper
 
-        def zone_writers(policy)
-          policy.zone_writers(@zone)
+        def lane_writers(policy)
+          verb = policy.verb_for_lane(@lane)
+          policy.roles_with_capability(verb)
         rescue UsageError => e
           raise UsageError.new("entry '#{@key}': #{e.message}")
         end
 
-        def in_proposal_zone?(policy) = policy.queue_zone?(@zone)
+        def in_proposal_lane?(policy) = policy.queue_lane?(@lane)
 
         def nested?  = false
         def derived? = false
@@ -36,6 +37,9 @@ module Textus
         def external?   = false
         def projection? = false
 
+        alias zone lane
+        alias in_proposal_zone? in_proposal_lane?
+
         # Whether git should track this entry's file. Default true; an entry
         # marked `tracked: false` in the manifest stays protocol-readable but is
         # listed in the generated `.gitignore` (ADR 0043). Cross-cutting, so it
@@ -60,19 +64,19 @@ module Textus
         # Minimal context object passed into entry `publish_via` hooks.
         # Everything beyond the three primitives is derived. Data.define
         # instances are frozen, so we recompute per-call rather than
-        # memoizing — RoleScope/Hooks::Context construction is cheap.
+        # memoizing — RoleScope/Step::Context construction is cheap.
         PublishContext = ::Data.define(:container, :call, :reader) do
           def manifest   = container.manifest
           def root       = container.root
           def repo_root  = File.dirname(container.root)
-          def events     = container.events
+          def steps      = container.steps
 
           def hook_context
-            Textus::Hooks::Context.new(scope: scope_for_hooks)
+            Textus::Step::Context.new(scope: scope_for_hooks)
           end
 
           def emit(event, **payload)
-            events.publish(event, ctx: hook_context, **payload)
+            steps.publish(event, ctx: hook_context, **payload)
           end
 
           # Read a named template from the store's templates/ directory.
@@ -91,7 +95,7 @@ module Textus
           private
 
           def scope_for_hooks
-            Textus::RoleScope.new(
+            Textus::Surfaces::RoleScope.new(
               container: container, role: call.role, dry_run: call.dry_run,
             )
           end

data/lib/textus/manifest/entry/parser.rb

@@ -5,7 +5,7 @@ module Textus
         def self.call(raw)
           key = raw["key"] or raise UsageError.new("manifest entry missing key")
           path = raw["path"] or raise UsageError.new("manifest entry '#{key}' missing path")
-          zone = raw["zone"] or raise UsageError.new("manifest entry '#{key}' missing zone")
+          lane = raw["lane"] or raise UsageError.new("manifest entry '#{key}' missing lane")
 
           raw_kind = raw["kind"] or raise BadManifest.new("entry '#{key}' missing required `kind:` (#{Entry::REGISTRY.keys.join("|")})")
           kind = raw_kind.to_sym
@@ -19,7 +19,7 @@ module Textus
 
           common = {
             raw: raw,
-            key: key, path: path, zone: zone,
+            key: key, path: path, lane: lane,
             schema: raw["schema"], owner: raw["owner"],
             format: format,
             publish_targets: publish_targets(raw)
@@ -31,12 +31,12 @@ module Textus
         end
 
         # ADR 0093: an entry's production block is the unified `source:`. Returns a
-        # Domain::Policy::Source; kind (intake/derived) is read from source.from.
+        # Manifest::Policy::Source; kind (intake/derived) is read from source.from.
         def self.parse_source(raw, key)
           block = raw["source"] or
-            raise BadManifest.new("entry '#{key}' requires a source: { from: project|handler|command, ... }")
+            raise BadManifest.new("entry '#{key}' requires a source: { from: derive|fetch|external, ... }")
 
-          Textus::Domain::Policy::Source.new(block)
+          Textus::Manifest::Policy::Source.new(block)
         end
 
         # ADR 0094: `publish:` is a LIST of target objects — to-targets
@@ -52,7 +52,7 @@ module Textus
               "[{to:, template:?} | {tree:}] (ADR 0094); the `publish: { … }` map form was retired",
             )
           end
-          block.map { |t| Textus::Domain::Policy::PublishTarget.new(t) }
+          block.map { |t| Textus::Manifest::Policy::PublishTarget.new(t) }
         end
 
         def self.resolve_format(raw, path)

data/lib/textus/manifest/entry/produced.rb

@@ -17,6 +17,8 @@ module Textus
         def derived?    = @source.kind == :derived
         def external?   = @source.external?
         def projection? = @source.projection?
+        def fetch?      = @source.fetch?
+        def derive?     = @source.derive?
         def nested?     = !!@raw["nested"]
         def handler     = @source.handler
         def config      = @source.config
@@ -33,11 +35,10 @@ module Textus
         def publish_via(pctx, prefix: nil)
           built = false
           if projection?
-            Textus::Produce::Acquire::Projection.new(container: pctx.container, call: pctx.call).run(self)
+            Textus::Pipeline::Acquire::Projection.new(container: pctx.container, call: pctx.call).run(self)
             built = true
             pctx.emit(:entry_produced, key: @key, envelope: pctx.reader.call(@key), sources: Array(@source.select).compact)
           end
-
           emitted = publish_mode.publish(pctx, prefix: prefix)
           return emitted if emitted
           return nil unless built

data/lib/textus/manifest/entry/publish/mode.rb

@@ -36,7 +36,7 @@ module Textus
 
           # Store-side directory this entry's tree lives under.
           def store_base(pctx)
-            File.join(pctx.root, "zones", entry.path)
+            File.join(pctx.root, Textus::Key::Path.normalize_relative_path(entry.path))
           end
         end
       end

data/lib/textus/manifest/entry/publish/to_paths.rb

@@ -16,11 +16,12 @@ module Textus
 
           def publish(pctx, prefix: nil) # rubocop:disable Lint/UnusedMethodArgument,Metrics/AbcSize
             targets = entry.publish_targets.select(&:to_target?)
+
             return nil if targets.empty?
 
             data_path = pctx.manifest.resolver.resolve(entry.key).path
             envelope  = pctx.reader.call(entry.key)
-            renderer  = Textus::Produce::Render.new(template_loader: ->(n) { pctx.read_template(n) })
+            renderer  = Textus::Pipeline::Render.new(template_loader: ->(n) { pctx.read_template(n) })
             content = nil # parsed lazily; the data's `content` (always _meta-free)
 
             targets.each do |t|

data/lib/textus/manifest/entry/validators/events.rb

@@ -4,7 +4,7 @@ module Textus
       module Validators
         module Events
           def self.call(entry, policy: nil) # rubocop:disable Lint/UnusedMethodArgument
-            pubsub_events = Textus::Hooks::Catalog::PUBSUB.keys
+            pubsub_events = Textus::Step::Catalog::PUBSUB.keys
             events = entry.events
             events.each_key do |evt|
               next if pubsub_events.include?(evt.to_sym)

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

@@ -1,14 +1,14 @@
 module Textus
-  module Domain
-    module Policy
-      class HandlerAllowlist
+  class Manifest
+    class Policy
+      class HandlerPermit
         attr_reader :handlers
 
         def initialize(handlers:)
           @handlers = Array(handlers).map(&:to_s).freeze
         end
 
-        def allows?(handler)
+        def permits?(handler)
           @handlers.include?(handler.to_s)
         end
       end

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

@@ -1,6 +1,6 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       module Matcher
         module_function
 

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

@@ -1,6 +1,6 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       # One publish destination (ADR 0094). Exactly one of:
       #   to-target   { to:, template:?, inject_boot:? }  — render data through a
       #               template, or copy verbatim when no template

data/lib/textus/manifest/policy/react.rb

@@ -0,0 +1,30 @@
+module Textus
+  class Manifest
+    class Policy
+      class React
+        ALLOWED_KEYS = %w[on when do scope budget idempotency observe priority].freeze
+
+        attr_reader :raw
+
+        def initialize(raw:)
+          raise Textus::BadManifest.new("react: must be a map") unless raw.is_a?(Hash)
+
+          raw = raw.each_with_object({}) do |(key, value), out|
+            normalized = key == true ? "on" : key.to_s
+            out[normalized] = value
+          end
+          raise Textus::BadManifest.new("react.ttl is invalid; ttl belongs only to source.ttl or retention.ttl") if raw.key?("ttl")
+
+          unknown = raw.keys - ALLOWED_KEYS
+          raise Textus::BadManifest.new("react: unknown key(s): #{unknown.join(", ")}") unless unknown.empty?
+
+          @raw = raw
+        end
+
+        def to_h
+          @raw
+        end
+      end
+    end
+  end
+end