textus 0.29.0 → 0.30.0

data/lib/textus/hooks/event_bus.rb

@@ -39,7 +39,12 @@ module Textus
         raise UsageError.new("#{event_sym} is an RPC event; register on RpcRegistry") if RPC_EVENTS.include?(event_sym)
 
         required = EVENTS[event_sym] or raise UsageError.new("unknown event: #{event}")
-        shape_check!(event_sym, required, blk)
+        sig = Signature.new(blk)
+        missing = sig.missing(required)
+        if missing.any?
+          raise UsageError.new("#{event_sym} hooks must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})")
+        end
+
         name = name.to_sym
         raise UsageError.new("#{event_sym} hook '#{name}' already registered") if @pubsub[event_sym].any? { |h| h[:name] == name }
 
@@ -79,8 +84,9 @@ module Textus
       private
 
       def invoke(event, sub, key, kwargs)
-        accepted = filter_kwargs(sub[:callable], kwargs)
+        accepted = Signature.new(sub[:callable]).filter(kwargs)
         error = nil
+        # Thread#kill is unsafe in general but bounded here: post-commit, isolated, only a runaway user hook is affected.
         thread = Thread.new do
           sub[:callable].call(**accepted)
         rescue StandardError => e
@@ -115,24 +121,6 @@ module Textus
         end
       end
 
-      def filter_kwargs(callable, kwargs)
-        params = callable.parameters
-        return kwargs if params.any? { |type, _| type == :keyrest }
-
-        accepted = params.each_with_object([]) { |(t, n), acc| acc << n if %i[key keyreq].include?(t) }
-        kwargs.slice(*accepted)
-      end
-
-      def shape_check!(event, required, blk)
-        provided = blk.parameters.select { |t, _| %i[keyreq key keyrest].include?(t) } # rubocop:disable Style/HashSlice
-        return if provided.any? { |t, _| t == :keyrest }
-
-        missing = required - provided.map { |_, n| n }
-        return if 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?
 

data/lib/textus/hooks/rpc_registry.rb

@@ -20,7 +20,10 @@ module Textus
         raise UsageError.new("#{event_sym} is a pubsub event; register on EventBus") if PUBSUB_EVENTS.include?(event_sym)
 
         required = EVENTS[event_sym] or raise UsageError.new("unknown RPC event: #{event}")
-        shape_check!(event_sym, required, blk)
+        sig = Signature.new(blk)
+        missing = sig.missing(required)
+        raise UsageError.new("#{event_sym} RPC must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})") if missing.any?
+
         name = name.to_sym
         raise UsageError.new("#{event_sym} '#{name}' already registered") if @table[event_sym].key?(name)
 
@@ -33,45 +36,16 @@ module Textus
         @table[event.to_sym][name.to_sym] or raise UsageError.new("unknown #{event}: #{name}")
       end
 
-      # Invoke a registered callable, injecting `caps:` under the kwarg name
-      # the callable declares. Legacy `store:` is rejected (no shim).
+      # Invoke a registered callable, injecting `caps:` only if the callable
+      # declares it (or accepts keyrest). Mis-named kwargs (e.g. the legacy
+      # `caps:`-alternative) are rejected at registration time, not here.
       def invoke(event, name, caps:, **other)
         blk = callable(event, name)
-        params = blk.parameters
-        accepts_keyrest = params.any? { |t, _| t == :keyrest }
-        declared = params.each_with_object([]) { |(t, n), acc| acc << n if %i[key keyreq].include?(t) }
-
-        if declared.include?(:store)
-          raise UsageError.new(
-            "RPC callable for #{event} '#{name}' declares legacy `store:`; rename to `caps:` " \
-            "(Textus::Container)",
-          )
-        end
-
+        sig = Signature.new(blk)
         kwargs = other.dup
-        kwargs[:caps] = caps if accepts_keyrest || declared.include?(:caps)
+        kwargs[:caps] = caps if sig.accepts_keyrest? || sig.declared_keys.include?(:caps)
         blk.call(**kwargs)
       end
-
-      private
-
-      def shape_check!(event, required, blk)
-        provided = blk.parameters.select { |t, _| %i[keyreq key keyrest].include?(t) } # rubocop:disable Style/HashSlice
-        return if provided.any? { |t, _| t == :keyrest }
-
-        param_names = provided.map { |_, n| n }
-        # Allow `store:` as a stand-in for `caps:` so registration succeeds;
-        # invoke will raise UsageError when the callable is actually called.
-        effective_required = if param_names.include?(:store)
-                               required.map { |r| r == :caps ? :store : r }
-                             else
-                               required
-                             end
-        missing = effective_required - param_names
-        return if missing.empty?
-
-        raise UsageError.new("#{event} RPC must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})")
-      end
     end
   end
 end

data/lib/textus/hooks/signature.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Textus
+  module Hooks
+    class Signature
+      def initialize(callable)
+        @params = callable.parameters
+      end
+
+      def accepts_keyrest?
+        @params.any? { |type, _| type == :keyrest }
+      end
+
+      def declared_keys
+        @params.each_with_object([]) { |(t, n), acc| acc << n if %i[keyreq key].include?(t) }
+      end
+
+      def missing(required)
+        return [] if accepts_keyrest?
+
+        required - declared_keys
+      end
+
+      def filter(kwargs)
+        return kwargs if accepts_keyrest?
+
+        kwargs.slice(*declared_keys)
+      end
+    end
+  end
+end

data/lib/textus/init.rb

@@ -7,14 +7,15 @@ module Textus
     DEFAULT_MANIFEST = <<~YAML
       version: textus/3
       zones:
-        - { name: identity, write_policy: [human],               read_policy: [all] }
-        - { name: working,  write_policy: [human, agent, runner], read_policy: [all] }
-        - { name: intake,   write_policy: [runner],              read_policy: [all] }
-        - { name: review,   write_policy: [agent, human],        read_policy: [all] }
-        - { name: output,   write_policy: [builder],             read_policy: [all] }
+        - { name: identity, kind: origin,     write_policy: [human],          read_policy: [all] }
+        - { name: working,  kind: origin,     write_policy: [human],          read_policy: [all] }
+        - { name: intake,   kind: quarantine, write_policy: [runner],         read_policy: [all] }
+        - { name: review,   kind: queue,      write_policy: [agent, human],   read_policy: [all] }
+        - { name: output,   kind: derived,    write_policy: [builder],        read_policy: [all] }
       entries:
         - { 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 }
+        - { key: review.notes,  path: review/notes,     zone: review,   schema: null, owner: agent:self, nested: true, kind: nested }
     YAML
 
     HOOKS_README = <<~MD
@@ -34,7 +35,7 @@ module Textus
         end
 
         reg.on(:transform_rows, :my_source) { |rows:, **| rows.map { |r| r.merge(processed: true) } }
-        reg.on(:validate,       :my_check)  { |store:, **| [] }
+        reg.on(:validate,       :my_check)  { |caps:, **| [] }
         reg.on(:entry_put,      :my_listener, keys: ["working.*"]) { |key:, envelope:, **| }
 
         # Run a side-effect every time textus writes a file to your repo:

data/lib/textus/manifest/data.rb

@@ -11,7 +11,8 @@ module Textus
     class Data
       AUDIT_DEFAULTS = { max_size: 10_485_760, keep: 5 }.freeze
 
-      attr_reader :raw, :root, :entries, :zones, :zone_readers, :audit_config, :role_mapping, :policy
+      attr_reader :raw, :root, :entries, :zones, :zone_readers, :declared_zone_kinds,
+                  :audit_config, :role_mapping, :policy
 
       def self.validate_key!(key)
         raise UsageError.new("empty key") if key.nil? || key.empty?
@@ -38,6 +39,9 @@ module Textus
           rp = z["read_policy"]
           [z["name"], rp.nil? ? :all : Array(rp)]
         end
+        @declared_zone_kinds = Array(raw["zones"]).to_h do |z|
+          [z["name"], z["kind"]&.to_sym]
+        end
         @audit_config = build_audit_config(raw)
         @role_mapping = RoleKinds.resolve(raw["roles"])
         # Policy is constructed before entries because Entry validators

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

@@ -23,8 +23,8 @@ module Textus
           raise UsageError.new("entry '#{@key}': #{e.message}")
         end
 
-        def in_generator_zone?(policy) = policy.zone_kinds(@zone).include?(:generator)
-        def in_proposal_zone?(policy)  = policy.zone_kinds(@zone).include?(:proposer)
+        def in_generator_zone?(policy) = policy.derived_zone?(@zone)
+        def in_proposal_zone?(policy)  = policy.queue_zone?(@zone)
 
         def nested?  = false
         def derived? = false

data/lib/textus/manifest/policy.rb

@@ -2,11 +2,13 @@ module Textus
   class Manifest
     # Authority over zones and roles derived from a Manifest::Data snapshot.
     # Encapsulates the lookups previously living on Manifest itself
-    # (zone_writers, zone_kinds, permission_for, role_kind, roles_with_kind).
+    # (zone_writers, permission_for, role_kind, roles_with_kind). Derived /
+    # proposal-queue status is authoritative via the declared-kind family
+    # (declared_kind, derived_zone?, queue_zone?, queue_zone), not inferred
+    # from writers.
     class Policy
       def initialize(data)
         @data = data
-        @zone_kinds_cache = {}
       end
 
       def zone_writers(zone_name)
@@ -25,11 +27,24 @@ module Textus
         )
       end
 
-      def zone_kinds(zone_name)
-        @zone_kinds_cache[zone_name] ||= zone_writers(zone_name).each_with_object(Set.new) do |w, acc|
-          k = role_kind(w)
-          acc << k if k
-        end.freeze
+      # The kind declared on a zone in the manifest, or nil if undeclared.
+      def declared_kind(zone_name)
+        @data.declared_zone_kinds[zone_name]
+      end
+
+      # The single zone declaring `kind: queue`, or nil. Schema guarantees <=1.
+      def queue_zone
+        @data.declared_zone_kinds.key(:queue)
+      end
+
+      # A zone is derived iff it declares kind: derived.
+      def derived_zone?(zone_name)
+        declared_kind(zone_name) == :derived
+      end
+
+      # A zone is a proposal queue iff it declares kind: queue.
+      def queue_zone?(zone_name)
+        declared_kind(zone_name) == :queue
       end
 
       def role_mapping
@@ -43,6 +58,18 @@ module Textus
       def roles_with_kind(kind)
         @data.role_mapping.each_with_object([]) { |(name, k), acc| acc << name if k == kind }
       end
+
+      # The zone a proposer role writes proposals into: the single zone 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)
+        return nil if role.nil?
+
+        q = queue_zone
+        return nil unless q && zone_writers(q).include?(role)
+
+        q
+      end
     end
   end
 end

data/lib/textus/manifest/rules.rb

@@ -51,7 +51,7 @@ module Textus
           @refresh = parse_refresh(raw["refresh"])
           @handler_allowlist = parse_handler_allowlist(raw["intake_handler_allowlist"])
           @promote = parse_promotion(raw["promotion"])
-          @retention = raw["retention"] # reserved — passthrough only
+          @retention = parse_retention(raw["retention"])
         end
 
         private
@@ -80,6 +80,15 @@ module Textus
 
           Textus::Domain::Policy::Promote.new(requires: Array(h["requires"]))
         end
+
+        def parse_retention(h)
+          return nil if h.nil?
+
+          Textus::Domain::Policy::Retention.new(
+            expire_after: h["expire_after"],
+            archive_after: h["archive_after"],
+          )
+        end
       end
     end
   end

data/lib/textus/manifest/schema.rb

@@ -4,8 +4,14 @@ module Textus
       ROOT_KEYS    = %w[version roles zones entries rules audit].freeze
       ROLE_KEYS    = %w[name kind].freeze
       ROLE_KINDS   = %w[accept_authority generator proposer runner].freeze
-      ZONE_KEYS    = %w[name write_policy read_policy].freeze
-      ENTRY_KEYS   = %w[
+      ZONE_KEYS    = %w[name kind write_policy read_policy].freeze
+      ZONE_KINDS   = %w[origin quarantine queue derived].freeze
+      KIND_REQUIRES_ROLE_KIND = {
+        "derived" => "generator",
+        "queue" => "proposer",
+        "quarantine" => "runner",
+      }.freeze
+      ENTRY_KEYS = %w[
         key path zone kind schema owner nested format
         compute template publish_to publish_each
         intake events inject_boot index_filename
@@ -15,8 +21,9 @@ module Textus
       RULE_KEYS    = %w[match refresh intake_handler_allowlist promotion retention].freeze
       REFRESH_KEYS = %w[ttl on_stale sync_budget_ms fetch_timeout_seconds].freeze
       FETCH_TIMEOUT_SECONDS_CEILING = 3600
-      PROMOTION_KEYS = %w[requires].freeze
-      AUDIT_KEYS     = %w[max_size keep].freeze
+      PROMOTION_KEYS  = %w[requires].freeze
+      RETENTION_KEYS  = %w[expire_after archive_after].freeze
+      AUDIT_KEYS = %w[max_size keep].freeze
 
       def self.validate!(raw)
         raise BadManifest.new("manifest must be a hash") unless raw.is_a?(Hash)
@@ -28,11 +35,21 @@ module Textus
         validate_rules!(raw["rules"])
         walk(raw["audit"], AUDIT_KEYS, "$.audit") if raw["audit"].is_a?(Hash)
         validate_zone_writers_declared!(raw)
+        validate_single_queue!(raw)
+        validate_zone_kind_consistency!(raw)
       end
 
       def self.validate_zones!(zones)
         Array(zones).each_with_index do |z, i|
           walk(z, ZONE_KEYS, "$.zones[#{i}]")
+          if z["kind"].nil?
+            raise BadManifest.new("zone '#{z["name"]}' at '$.zones[#{i}]' must declare a kind (one of: #{ZONE_KINDS.join(", ")})")
+          end
+          next if ZONE_KINDS.include?(z["kind"])
+
+          raise BadManifest.new(
+            "unknown zone kind '#{z["kind"]}' at '$.zones[#{i}]' (known: #{ZONE_KINDS.join(", ")})",
+          )
         end
       end
 
@@ -54,6 +71,7 @@ module Textus
             validate_fetch_timeout!(r["refresh"]["fetch_timeout_seconds"], "#{path}.refresh.fetch_timeout_seconds")
           end
           walk(r["promotion"], PROMOTION_KEYS, "#{path}.promotion") if r["promotion"].is_a?(Hash)
+          walk(r["retention"], RETENTION_KEYS, "#{path}.retention") if r["retention"].is_a?(Hash)
         end
       end
 
@@ -115,6 +133,38 @@ module Textus
           raise BadManifest.new("unknown key '#{k}' at '#{path}'")
         end
       end
+
+      def self.validate_single_queue!(raw)
+        queues = Array(raw["zones"]).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(", ")})",
+        )
+      end
+
+      def self.validate_zone_kind_consistency!(raw)
+        mapping = role_kind_mapping(raw)
+        Array(raw["zones"]).each do |z|
+          required = KIND_REQUIRES_ROLE_KIND[z["kind"]] or next
+          writers  = Array(z["write_policy"])
+          next if writers.any? { |w| mapping[w] == required }
+
+          raise BadManifest.new(
+            "zone '#{z["name"]}' declares kind: #{z["kind"]} but no writer is a #{required} " \
+            "(writers: #{writers.join(", ")})",
+          )
+        end
+      end
+
+      # name => kind string, honouring an explicit roles: block or the default mapping.
+      def self.role_kind_mapping(raw)
+        if raw["roles"].nil?
+          RoleKinds::DEFAULT_MAPPING.transform_values(&:to_s)
+        else
+          Array(raw["roles"]).to_h { |r| [r["name"], r["kind"]] }
+        end
+      end
     end
   end
 end

data/lib/textus/manifest.rb

@@ -6,10 +6,11 @@ module Textus
   #
   #   * data     — frozen value: raw, root, zones, entries, audit_config, role_mapping
   #   * resolver — resolves keys → entry + path
-  #   * policy   — zone/role authority (zone_writers, zone_kinds, permission_for, …)
+  #   * policy   — zone/role authority (zone_writers, declared_kind/derived_zone?/
+  #     queue_zone?, permission_for, …)
   #   * rules    — match-block rule engine (refresh, handler allowlist, promotion, …)
   #
-  # Use `manifest.data.entries`, `manifest.policy.zone_kinds(z)`, etc.
+  # Use `manifest.data.entries`, `manifest.policy.declared_kind(z)`, etc.
   Manifest = Data.define(:data, :resolver, :policy, :rules)
 end
 

data/lib/textus/mcp/server.rb

@@ -50,15 +50,7 @@ module Textus
 
       def handle_initialize(rid, _params)
         proposer = @store.manifest.policy.roles_with_kind(:proposer).first
-        propose_zone = nil
-        if proposer
-          @store.manifest.data.zones.each do |zname, writers|
-            if writers.include?(proposer) && zname.include?("review")
-              propose_zone = zname
-              break
-            end
-          end
-        end
+        propose_zone = @store.manifest.policy.propose_zone_for(proposer)
 
         @session = Session.new(
           role: @role,

data/lib/textus/mcp/session.rb

@@ -1,29 +1,15 @@
 module Textus
   module MCP
-    # Per-connection state held by the server. Immutable; advance_cursor
-    # returns a new instance.
-    class Session
-      attr_reader :role, :cursor, :propose_zone, :manifest_etag
-
-      def initialize(role:, cursor:, propose_zone:, manifest_etag:)
-        @role = role
-        @cursor = cursor
-        @propose_zone = propose_zone
-        @manifest_etag = manifest_etag
-      end
-
-      def advance_cursor(new_cursor)
-        self.class.new(
-          role: @role, cursor: new_cursor,
-          propose_zone: @propose_zone, manifest_etag: @manifest_etag
-        )
-      end
+    # Per-connection state held by the server. Immutable Data value;
+    # advance_cursor returns a new instance via #with.
+    Session = Data.define(:role, :cursor, :propose_zone, :manifest_etag) do
+      def advance_cursor(new_cursor) = with(cursor: new_cursor)
 
       def check_etag!(observed_etag)
-        return if observed_etag == @manifest_etag
+        return if observed_etag == manifest_etag
 
         raise ContractDrift.new(
-          "manifest changed (was #{short_etag(@manifest_etag)}, now #{short_etag(observed_etag)}); re-run boot",
+          "manifest changed (was #{short_etag(manifest_etag)}, now #{short_etag(observed_etag)}); re-run boot",
         )
       end
 
@@ -32,9 +18,7 @@ module Textus
       # First 8 hex chars after the "sha256:" prefix — a stable short id for
       # the drift diagnostic. Tolerates non-prefixed values (delete_prefix is
       # a no-op when the prefix is absent).
-      def short_etag(etag)
-        etag.to_s.delete_prefix("sha256:")[0, 8]
-      end
+      def short_etag(etag) = etag.to_s.delete_prefix("sha256:")[0, 8]
     end
   end
 end

data/lib/textus/read/policy_explain.rb

@@ -20,6 +20,7 @@ module Textus
               refresh: !b.refresh.nil?,
               handler_allowlist: !b.handler_allowlist.nil?,
               promote: !b.promote.nil?,
+              retention: !b.retention.nil?,
             }
           end,
           effective: {
@@ -29,6 +30,10 @@ module Textus
             },
             handler_allowlist: winners.handler_allowlist&.handlers,
             promotion: winners.promote && { requires: winners.promote.requires },
+            retention: winners.retention && {
+              expire_after: winners.retention.expire_after,
+              archive_after: winners.retention.archive_after,
+            },
           },
         }
       end

data/lib/textus/read/retainable.rb

@@ -0,0 +1,17 @@
+module Textus
+  module Read
+    class Retainable
+      def initialize(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
+        @manifest = container.manifest
+      end
+
+      def call(prefix: nil, zone: nil)
+        Textus::Domain::Retention.new(
+          manifest: @manifest,
+          file_stat: Textus::Ports::Storage::FileStat.new,
+          clock: Textus::Ports::Clock,
+        ).call(prefix: prefix, zone: zone)
+      end
+    end
+  end
+end

data/lib/textus/role_scope.rb

@@ -38,11 +38,12 @@ module Textus
 
     Textus::Dispatcher::VERBS.each_key do |verb|
       define_method(verb) do |*args, **kwargs|
-        klass = Textus::Dispatcher.fetch(verb)
         call_value = Textus::Call.build(
           role: @role, correlation_id: @correlation_id, dry_run: @dry_run,
         )
-        klass.new(container: @container, call: call_value).call(*args, **kwargs)
+        Textus::Dispatcher.invoke(
+          verb, container: @container, call: call_value, args: args, kwargs: kwargs
+        )
       end
     end
   end

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.29.0"
+  VERSION = "0.30.0"
   PROTOCOL = "textus/3"
 end

data/lib/textus/write/delete.rb

@@ -33,21 +33,7 @@ module Textus
       end
 
       def writer
-        @writer ||= Textus::Envelope::IO::Writer.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-          schemas: @container.schemas,
-          audit_log: @container.audit_log,
-          call: @call,
-          reader: reader,
-        )
-      end
-
-      def reader
-        @reader ||= Textus::Envelope::IO::Reader.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-        )
+        @writer ||= Textus::Envelope::IO::Writer.from(container: @container, call: @call)
       end
     end
   end

data/lib/textus/write/intake_fetch.rb

@@ -0,0 +1,23 @@
+require "timeout"
+
+module Textus
+  module Write
+    # Invokes a :resolve_intake hook handler by name under a timeout.
+    # The transport-side fetch kernel shared by `textus put --fetch` and
+    # `textus hook run`. Maps Timeout::Error to a UsageError; leaves any
+    # other error to the caller (call sites differ in how they wrap those).
+    module IntakeFetch
+      FETCH_TIMEOUT_SECONDS = 30
+
+      module_function
+
+      def invoke(rpc:, handler:, config:, args:, label:, timeout: FETCH_TIMEOUT_SECONDS)
+        Timeout.timeout(timeout) do
+          rpc.invoke(:resolve_intake, handler, caps: nil, config: config, args: args)
+        end
+      rescue Timeout::Error
+        raise Textus::UsageError.new("#{label} '#{handler}' exceeded #{timeout}s timeout")
+      end
+    end
+  end
+end

data/lib/textus/write/mv.rb

@@ -102,21 +102,11 @@ module Textus
       end
 
       def writer
-        @writer ||= Textus::Envelope::IO::Writer.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-          schemas: @container.schemas,
-          audit_log: @container.audit_log,
-          call: @call,
-          reader: reader,
-        )
+        @writer ||= Textus::Envelope::IO::Writer.from(container: @container, call: @call)
       end
 
       def reader
-        @reader ||= Textus::Envelope::IO::Reader.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-        )
+        @reader ||= Textus::Envelope::IO::Reader.from(container: @container)
       end
     end
   end

data/lib/textus/write/put.rb

@@ -38,21 +38,7 @@ module Textus
       end
 
       def writer
-        @writer ||= Textus::Envelope::IO::Writer.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-          schemas: @container.schemas,
-          audit_log: @container.audit_log,
-          call: @call,
-          reader: reader,
-        )
-      end
-
-      def reader
-        @reader ||= Textus::Envelope::IO::Reader.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-        )
+        @writer ||= Textus::Envelope::IO::Writer.from(container: @container, call: @call)
       end
     end
   end

data/lib/textus/write/refresh_worker.rb

@@ -3,7 +3,7 @@ require "timeout"
 module Textus
   module Write
     class RefreshWorker
-      FETCH_TIMEOUT_SECONDS = 30
+      FETCH_TIMEOUT_SECONDS = IntakeFetch::FETCH_TIMEOUT_SECONDS
 
       def initialize(container:, call:)
         @container    = container
@@ -117,21 +117,7 @@ module Textus
       end
 
       def writer
-        @writer ||= Textus::Envelope::IO::Writer.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-          schemas: @container.schemas,
-          audit_log: @container.audit_log,
-          call: @call,
-          reader: reader,
-        )
-      end
-
-      def reader
-        @reader ||= Textus::Envelope::IO::Reader.new(
-          file_store: @container.file_store,
-          manifest: @container.manifest,
-        )
+        @writer ||= Textus::Envelope::IO::Writer.from(container: @container, call: @call)
       end
     end
   end