textus 0.54.2 → 0.55.1

data/lib/textus/action/rule_explain.rb

@@ -3,8 +3,6 @@
 module Textus
   module Action
     class RuleExplain < Base
-      extend Textus::Contract::DSL
-
       verb :rule_explain
       summary "Effective rules for a key. Lean {lifecycle, guard} by default; detail: true adds matched blocks + guard predicates."
       surfaces :cli, :mcp
@@ -15,15 +13,9 @@ module Textus
           description: "defaults false: lean {lifecycle, guard}. detail: true adds matched blocks + guard predicates per transition."
       view(:cli) { |r| { "verb" => "rule_explain" }.merge(r.transform_keys(&:to_s)) }
 
-      def initialize(key:, detail: nil)
-        super()
-        @key = key
-        @detail = detail
-      end
-
-      def call(container:, **)
-        @manifest = container.manifest
-        @detail ? explain(@key) : effective(@key)
+      def self.call(container:, call:, key:, detail: nil) # rubocop:disable Lint/UnusedMethodArgument
+        manifest = container.manifest
+        Success(detail ? explain(manifest, key) : effective(manifest, key))
       end
 
       REGISTRY = Textus::Manifest::Schema::FIELD_REGISTRY
@@ -31,17 +23,15 @@ module Textus
       DETAIL_FIELDS = REGISTRY.select { |_, m| m[:in_rule_explain].include?(:detail) }.keys.freeze
       EFFECTIVE_FIELDS = DETAIL_FIELDS.select { |f| REGISTRY[f][:policy_class] }.freeze
 
-      private
-
-      def effective(key)
-        set = @manifest.rules.for(key)
+      def self.effective(manifest, key)
+        set = manifest.rules.for(key)
         LEAN_FIELDS.each_with_object({}) do |field, out|
           value = set.public_send(field)
           out[field.to_s] = lean_value(field, value) unless value.nil?
         end
       end
 
-      def lean_value(field, value)
+      def self.lean_value(field, value)
         case field
         when :retention
           retention_hash(value, string_keys: true)
@@ -52,9 +42,9 @@ module Textus
         end
       end
 
-      def explain(key)
-        matching = @manifest.rules.explain(key)
-        winners = @manifest.rules.for(key)
+      def self.explain(manifest, key)
+        matching = manifest.rules.explain(key)
+        winners = manifest.rules.for(key)
         {
           key: key,
           matched_blocks: matching.map do |block|
@@ -63,13 +53,13 @@ module Textus
           effective: EFFECTIVE_FIELDS.to_h { |f| [f, effective_value(f, winners.public_send(f))] },
           guards: Textus::Gate::Auth::FLOOR.keys.to_h do |action|
             floor = Textus::Gate::Auth::FLOOR.fetch(action, [])
-            rule = Array(@manifest.rules.for(key).guard&.dig(action.to_s))
+            rule = Array(manifest.rules.for(key).guard&.dig(action.to_s))
             [action, { floor: floor, rule: rule }]
           end,
         }
       end
 
-      def effective_value(field, value)
+      def self.effective_value(field, value)
         return nil if value.nil?
 
         case field
@@ -82,7 +72,7 @@ module Textus
         end
       end
 
-      def retention_hash(retention, string_keys:)
+      def self.retention_hash(retention, string_keys:)
         h = { ttl_seconds: retention.ttl_seconds, action: retention.action }
         string_keys ? h.transform_keys(&:to_s) : h
       end

data/lib/textus/action/rule_lint.rb

@@ -5,8 +5,6 @@ require "yaml"
 module Textus
   module Action
     class RuleLint < Base
-      extend Textus::Contract::DSL
-
       verb :rule_lint
       summary "Diff candidate manifest YAML's rules against the live manifest. No writes."
       surfaces :cli, :mcp
@@ -15,15 +13,13 @@ module Textus
                                    description: "path to candidate manifest YAML; its `rules:` block is diffed against the live manifest"
       view { |v, _i| v.to_h }
 
-      def initialize(candidate_yaml:)
-        super()
-        @candidate_yaml = candidate_yaml
-      end
-
-      def call(container:, **)
+      def self.call(container:, call:, candidate_yaml:) # rubocop:disable Lint/UnusedMethodArgument
         root = container.root
         live_rules = current_rules(root)
-        candidate_rules = parse_candidate(@candidate_yaml)
+        candidate_result = parse_candidate(candidate_yaml)
+        return candidate_result if candidate_result.is_a?(Dry::Monads::Result::Failure)
+
+        candidate_rules = candidate_result
 
         live_by_match = live_rules.to_h { |rule| [rule["match"], rule] }
         candidate_by_match = candidate_rules.to_h { |rule| [rule["match"], rule] }
@@ -45,23 +41,21 @@ module Textus
           }
         end
 
-        Textus::Jobs::Plan.new(steps: steps, warnings: [])
+        Success(Textus::Store::Jobs::Plan.new(steps: steps, warnings: []))
       end
 
-      private
-
-      def current_rules(root)
+      def self.current_rules(root)
         raw = YAML.safe_load_file(File.join(root, "manifest.yaml"), permitted_classes: [Symbol], aliases: false)
         Array(raw["rules"])
       end
 
-      def parse_candidate(yaml_text)
+      def self.parse_candidate(yaml_text)
         raw = YAML.safe_load(yaml_text, permitted_classes: [Symbol], aliases: false)
-        raise UsageError.new("candidate is not a YAML mapping") unless raw.is_a?(Hash)
+        return Failure(code: :usage_error, message: "candidate is not a YAML mapping") unless raw.is_a?(Hash)
 
         Array(raw["rules"])
       rescue Psych::Exception => e
-        raise UsageError.new("candidate YAML parse error: #{e.message}")
+        Failure(code: :usage_error, message: "candidate YAML parse error: #{e.message}")
       end
     end
   end

data/lib/textus/action/rule_list.rb

@@ -3,31 +3,27 @@
 module Textus
   module Action
     class RuleList < Base
-      extend Textus::Contract::DSL
-
       verb :rule_list
       summary "List every rule block in the manifest."
       surfaces :cli
       cli "rule list"
       view(:cli) { |policies| { "verb" => "rule_list", "policies" => policies } }
 
-      def call(container:, **)
+      def self.call(container:, call:, **_options) # rubocop:disable Lint/UnusedMethodArgument
         manifest = container.manifest
-        manifest.rules.blocks.map do |block|
+        Success(manifest.rules.blocks.map do |block|
           row = { "match" => block.match }
-          self.class::LIST_FIELDS.each do |field|
+          LIST_FIELDS.each do |field|
             value = block.public_send(field)
             row[field.to_s] = serialize(field, value) unless value.nil?
           end
           row
-        end
+        end)
       end
 
       LIST_FIELDS = Textus::Manifest::Schema::FIELD_REGISTRY.select { |_, m| m[:in_rule_list] }.keys.freeze
 
-      private
-
-      def serialize(field, value)
+      def self.serialize(field, value)
         case field
         when :retention
           { "ttl_seconds" => value.ttl_seconds, "action" => value.action.to_s }

data/lib/textus/action/schema_envelope.rb

@@ -3,8 +3,6 @@
 module Textus
   module Action
     class SchemaEnvelope < Base
-      extend Textus::Contract::DSL
-
       verb :schema_show
       summary "Return the schema (field shape) for an entry's family, by key."
       surfaces :cli, :mcp
@@ -12,17 +10,12 @@ module Textus
       arg :key, String, required: true, positional: true,
                         description: "any key in the family whose schema you want; returns required/optional fields and their types"
 
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def call(container:, **)
+      def self.call(container:, key:, **)
         manifest = container.manifest
         schemas = container.schemas
-        mentry = manifest.resolver.resolve(@key).entry
+        mentry = manifest.resolver.resolve(key).entry
         schema = schemas.fetch_or_nil(mentry.schema)
-        { "protocol" => PROTOCOL, "key" => @key, "schema_ref" => mentry.schema, "schema" => schema&.to_h }
+        Success({ "protocol" => Textus::PROTOCOL, "key" => key, "schema_ref" => mentry.schema, "schema" => schema&.to_h })
       end
     end
   end

data/lib/textus/action/uid.rb

@@ -3,8 +3,6 @@
 module Textus
   module Action
     class Uid < Base
-      extend Textus::Contract::DSL
-
       verb :uid
       summary "Return the stable UID of an entry without reading its body."
       surfaces :cli
@@ -12,21 +10,9 @@ module Textus
       arg :key, String, required: true, positional: true, description: "entry key"
       view(:cli) { |uid, inputs| { "key" => inputs[:key], "uid" => uid } }
 
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def call(container:, call:)
-        Textus::Action::Get.new(key: @key).call(container: container, call: call).uid
-      end
-
-      def self.new(*args, **kwargs)
-        return super(**kwargs) unless args.any?
-
-        positional = instance_method(:initialize).parameters.slice(:keyreq, :key).map(&:last)
-        mapped = positional.zip(args).to_h
-        super(**mapped.merge(kwargs))
+      def self.call(container:, call:, key:)
+        envelope = Value::Result.unwrap(Textus::Action::Get.call(container: container, call: call, key: key))
+        Success(envelope.uid)
       end
     end
   end

data/lib/textus/action/where.rb

@@ -3,33 +3,18 @@
 module Textus
   module Action
     class Where < Base
-      extend Textus::Contract::DSL
-
       verb :where
       summary "Resolve a key to its zone, owner, and path without reading the body."
       surfaces :cli, :mcp
       arg :key, String, required: true, positional: true,
                         description: "dotted key to locate (returns zone, owner, path; does not read content)"
 
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def call(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
+      def self.call(container:, key:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
         manifest = container.manifest
-        res = manifest.resolver.resolve(@key)
+        res = manifest.resolver.resolve(key)
         mentry = res.entry
         path = res.path
-        { "protocol" => PROTOCOL, "key" => @key, "lane" => mentry.lane, "owner" => mentry.owner, "path" => path }
-      end
-
-      def self.new(*args, **kwargs)
-        return super(**kwargs) unless args.any?
-
-        positional = instance_method(:initialize).parameters.slice(:keyreq, :key).map(&:last)
-        mapped = positional.zip(args).to_h
-        super(**mapped.merge(kwargs))
+        Success({ "protocol" => Textus::PROTOCOL, "key" => key, "lane" => mentry.lane, "owner" => mentry.owner, "path" => path })
       end
     end
   end

data/lib/textus/boot.rb

@@ -90,8 +90,8 @@ module Textus
       propose_lane = manifest.policy.propose_lane_for(agent_role)
 
       {
-        "read_verbs" => Textus::Surfaces::MCP::Catalog.read_verbs,
-        "write_verbs" => agent_role ? Textus::Surfaces::MCP::Catalog.write_verbs : [],
+        "read_verbs" => Textus::Surface::MCP::Catalog.read_verbs,
+        "write_verbs" => agent_role ? Textus::Surface::MCP::Catalog.write_verbs : [],
         "writable_lanes" => writable_lanes,
         "propose_lane" => propose_lane,
         "latest_seq" => audit_log.latest_seq,
@@ -150,7 +150,7 @@ module Textus
 
     def self.build(container:)
       manifest = container.manifest
-      etag = Textus::Etag.for_contract(container.root)
+      etag = Textus::Value::Etag.for_contract(container.root)
 
       {
         "protocol" => PROTOCOL_ID,
@@ -160,7 +160,6 @@ module Textus
         "agent_quickstart" => agent_quickstart(manifest, container.audit_log),
         "orientation" => read_artifact_content(container, "artifacts.config.orientation"),
         "context" => read_boot_context(container),
-        "index_key" => index_key_if_present(container),
         "agent_protocol" => agent_protocol(manifest),
       }.compact
     end
@@ -169,8 +168,8 @@ module Textus
       res = container.manifest.resolver.resolve(key)
       return nil unless res.path && File.exist?(res.path)
 
-      call = Textus::Call.build(role: Textus::Role::DEFAULT)
-      env  = Textus::Action::Get.new(key: key).call(container: container, call: call)
+      call = Textus::Value::Call.build(role: Textus::Value::Role::DEFAULT)
+      env  = Textus::Action::Get.call(container: container, call: call, key: key)
       env&.content
     rescue Textus::Error
       nil
@@ -180,21 +179,14 @@ module Textus
       res = container.manifest.resolver.resolve("knowledge.boot")
       return nil unless res.path && File.exist?(res.path)
 
-      call = Textus::Call.build(role: Textus::Role::DEFAULT)
-      env  = Textus::Action::Get.new(key: "knowledge.boot").call(container: container, call: call)
+      call = Textus::Value::Call.build(role: Textus::Value::Role::DEFAULT)
+      env  = Textus::Action::Get.call(container: container, call: call, key: "knowledge.boot")
       body = env&.body&.strip
       body.nil? || body.empty? ? nil : body
     rescue Textus::Error
       nil
     end
 
-    def self.index_key_if_present(container)
-      res = container.manifest.resolver.resolve("artifacts.system.index")
-      res.path && File.exist?(res.path) ? "artifacts.system.index" : nil
-    rescue Textus::Error
-      nil
-    end
-
     def self.lanes_for(manifest)
       manifest.data.declared_lane_kinds.keys.map do |name|
         verb = manifest.policy.verb_for_lane(name)

data/lib/textus/contract/arg.rb

@@ -0,0 +1,10 @@
+module Textus
+  module Contract
+    Arg = Data.define(
+      :name, :type, :required, :positional, :session_default,
+      :description, :wire_name, :default, :source, :coerce, :cli_default
+    ) do
+      def wire = wire_name || name
+    end
+  end
+end

data/lib/textus/contract/dsl.rb

@@ -0,0 +1,88 @@
+module Textus
+  module Contract
+    module DSL
+      def verb(name = nil)
+        if name
+          raise "contract already built; declare verb before reading .contract" if defined?(@contract) && @contract
+
+          @__verb = name
+        else
+          @__verb
+        end
+      end
+
+      def summary(text = nil)
+        if text
+          raise "contract already built; declare summary before reading .contract" if defined?(@contract) && @contract
+
+          @__summary = text
+        else
+          @__summary
+        end
+      end
+
+      def surfaces(*list)
+        if list.empty?
+          @__surfaces ||= []
+        else
+          raise "contract already built; declare surfaces before reading .contract" if defined?(@contract) && @contract
+
+          @__surfaces = list
+        end
+      end
+
+      def cli(path = nil)
+        if path
+          raise "contract already built; declare cli before reading .contract" if defined?(@contract) && @contract
+
+          @__cli = path.to_s
+        else
+          @__cli
+        end
+      end
+
+      def arg(name, type, required: false, positional: false, session_default: nil, description: nil, wire_name: nil, default: nil, source: nil, coerce: nil, cli_default: :__unset) # rubocop:disable Metrics/ParameterLists,Layout/LineLength
+        raise "contract already built; declare args before reading .contract" if defined?(@contract) && @contract
+
+        (@__args ||= []) << Arg.new(
+          name: name, type: type, required: required,
+          positional: positional, session_default: session_default,
+          description: description, wire_name: wire_name, default: default,
+          source: source, coerce: coerce, cli_default: cli_default
+        )
+      end
+
+      def cli_stdin(mode = :__read)
+        return @__cli_stdin if mode == :__read
+
+        raise "contract already built; declare cli_stdin before reading .contract" if defined?(@contract) && @contract
+
+        @__cli_stdin = mode
+      end
+
+      def view(surface = :default, &blk)
+        return (@__views ||= {})[surface] unless blk
+
+        raise "contract already built; declare view before reading .contract" if defined?(@contract) && @contract
+
+        (@__views ||= {})[surface] = blk
+      end
+
+      def contract?
+        !@__verb.nil?
+      end
+
+      def contract
+        @contract ||= Spec.new(
+          verb: @__verb,
+          summary: @__summary,
+          args: (@__args || []).freeze,
+          surfaces: (@__surfaces || []).freeze,
+          views: ((@__views ||= {})[:default] ||= ->(v, _i) { v }) && @__views,
+          cli: @__cli,
+          cli_stdin: @__cli_stdin,
+        )
+      end
+    end
+  end
+end

data/lib/textus/contract/spec.rb

@@ -0,0 +1,25 @@
+module Textus
+  module Contract
+    Spec = Data.define(:verb, :summary, :args, :surfaces, :views, :cli, :cli_stdin) do
+      def mcp? = surfaces.include?(:mcp)
+      def cli? = surfaces.include?(:cli)
+
+      def view(surface = :default) = views[surface] || views.fetch(:default)
+      def cli_path = cli || verb.to_s
+      def cli_words = cli_path.split
+      def cli_group = cli_words.size > 1 ? cli_words.first : nil
+      def cli_leaf  = cli_words.last
+
+      def required_args = args.select(&:required)
+
+      def input_schema
+        props = args.to_h do |a|
+          h = { "type" => Contract.json_type(a.type) }
+          h["description"] = a.description if a.description
+          [a.wire.to_s, h]
+        end
+        { type: "object", properties: props, required: required_args.map { |a| a.wire.to_s } }
+      end
+    end
+  end
+end

data/lib/textus/contract.rb

@@ -1,29 +1,5 @@
 module Textus
-  # Declarative, co-located interface contract for a verb. One source of truth
-  # for the agent-facing summary, the argument schema, which transports expose
-  # the verb, and how the return value is shaped for the wire. CLI/Ruby/MCP and
-  # boot project from this; the MCP catalog is fully derived from it (ADR 0039).
   module Contract
-    # One argument of a verb. `positional: true` means it is passed to the
-    # use-case as a positional (e.g. `get(key)`); otherwise as a keyword.
-    # `session_default` names a zero-arg method on `Textus::Session` (Symbol)
-    # that supplies the value when the wire arg is absent; `nil` means no default.
-    # `wire_name` is the name the arg carries on the wire (MCP JSON property / CLI
-    # envelope key) when it must differ from the use-case kwarg `name` — e.g. `put`
-    # takes the `meta:` kwarg but exposes `_meta` on the wire to match what `get`
-    # returns and what the CLI `--stdin` envelope already speaks (ADR 0057).
-    # `source: :file` (CLI only) reads the arg's value as a path -> file
-    # contents; `coerce:` is a callable applied to the raw value (CLI only);
-    # `cli_default:` supplies a CLI-specific default that diverges from the
-    # contract `default` the agent surfaces use (`:__unset` sentinel = none).
-    Arg = Data.define(
-      :name, :type, :required, :positional, :session_default,
-      :description, :wire_name, :default, :source, :coerce, :cli_default
-    ) do
-      # The name used on the wire (defaults to the kwarg name).
-      def wire = wire_name || name
-    end
-
     JSON_TYPES = {
       String => "string", Integer => "integer", Hash => "object",
       Array => "array", :boolean => "boolean"
@@ -32,143 +8,5 @@ module Textus
     def self.json_type(type)
       JSON_TYPES.fetch(type) { raise ArgumentError.new("no JSON type mapping for #{type.inspect}") }
     end
-
-    Spec = Data.define(:verb, :summary, :args, :surfaces, :views, :cli, :around, :cli_stdin) do
-      def mcp? = surfaces.include?(:mcp)
-      def cli? = surfaces.include?(:cli)
-
-      # The output shaper for a surface; falls back to the default view. Every
-      # view is invoked uniformly as `view.call(result, inputs)` — a view that
-      # declares one parameter ignores `inputs` (procs tolerate extra args).
-      def view(surface = :default) = views[surface] || views.fetch(:default)
-
-      # Operator-facing command path. Defaults to the verb token; grouped verbs
-      # declare e.g. `cli "schema show"`.
-      def cli_path = cli || verb.to_s
-      def cli_words = cli_path.split
-      def cli_group = cli_words.size > 1 ? cli_words.first : nil
-      def cli_leaf  = cli_words.last
-
-      def required_args = args.select(&:required)
-
-      # JSON-Schema object for MCP tools/list inputSchema.
-      # Outer keys (:type, :properties, :required) are symbols; inner property
-      # keys are strings — matches the MCP/JSON wire shape expected by clients.
-      def input_schema
-        props = args.to_h do |a|
-          h = { "type" => Contract.json_type(a.type) }
-          h["description"] = a.description if a.description
-          [a.wire.to_s, h]
-        end
-        { type: "object", properties: props, required: required_args.map { |a| a.wire.to_s } }
-      end
-    end
-
-    # Mixed onto a use-case class via `extend`. Calls accumulate into ivars,
-    # frozen into a Spec on first read of `.contract`.
-    module DSL
-      def verb(name = nil)
-        if name
-          raise "contract already built; declare verb before reading .contract" if defined?(@__contract) && @__contract
-
-          @__verb = name
-        else
-          @__verb
-        end
-      end
-
-      def summary(text = nil)
-        if text
-          raise "contract already built; declare summary before reading .contract" if defined?(@__contract) && @__contract
-
-          @__summary = text
-        else
-          @__summary
-        end
-      end
-
-      def surfaces(*list)
-        if list.empty?
-          @__surfaces ||= []
-        else
-          raise "contract already built; declare surfaces before reading .contract" if defined?(@__contract) && @__contract
-
-          @__surfaces = list
-        end
-      end
-
-      def cli(path = nil)
-        if path
-          raise "contract already built; declare cli before reading .contract" if defined?(@__contract) && @__contract
-
-          @__cli = path.to_s
-        else
-          @__cli
-        end
-      end
-
-      # Declare a stateful wrapper resource (Contract::Around) to run around
-      # dispatch — e.g. `around :cursor` (pulse) or `around :build_lock` (build).
-      def around(name = nil)
-        return @__around unless name
-
-        raise "contract already built; declare around before reading .contract" if defined?(@__contract) && @__contract
-
-        @__around = name
-      end
-
-      def arg(name, type, required: false, positional: false, session_default: nil, description: nil, wire_name: nil, default: nil, source: nil, coerce: nil, cli_default: :__unset) # rubocop:disable Metrics/ParameterLists,Layout/LineLength
-        raise "contract already built; declare args before reading .contract" if defined?(@__contract) && @__contract
-
-        (@__args ||= []) << Arg.new(
-          name: name, type: type, required: required,
-          positional: positional, session_default: session_default,
-          description: description, wire_name: wire_name, default: default,
-          source: source, coerce: coerce, cli_default: cli_default
-        )
-      end
-
-      # Verb-level: the CLI reads its inputs from a stdin envelope of this mode.
-      # `:json` parses stdin as a JSON object and distributes its keys to args
-      # by wire-name. nil means no stdin acquisition.
-      def cli_stdin(mode = :__read)
-        return @__cli_stdin if mode == :__read
-
-        raise "contract already built; declare cli_stdin before reading .contract" if defined?(@__contract) && @__contract
-
-        @__cli_stdin = mode
-      end
-
-      # Declare an output shaper. `view { ... }` is the default (MCP + Ruby);
-      # `view(:cli) { ... }` overrides for the CLI. Both receive (result, inputs).
-      def view(surface = :default, &blk)
-        return (@__views ||= {})[surface] unless blk
-
-        raise "contract already built; declare view before reading .contract" if defined?(@__contract) && @__contract
-
-        (@__views ||= {})[surface] = blk
-      end
-
-      def contract?
-        !@__verb.nil?
-      end
-
-      # rubocop:disable Naming/MemoizedInstanceVariableName
-      # @__contract uses double-underscore to match the other accumulator ivars
-      # (@__verb, @__args, etc.) and avoid name collision with user-defined `@contract`.
-      def contract
-        @__contract ||= Spec.new(
-          verb: @__verb,
-          summary: @__summary,
-          args: (@__args || []).freeze,
-          surfaces: (@__surfaces || []).freeze,
-          views: ((@__views ||= {})[:default] ||= ->(v, _i) { v }) && @__views,
-          cli: @__cli,
-          around: @__around,
-          cli_stdin: @__cli_stdin,
-        )
-      end
-      # rubocop:enable Naming/MemoizedInstanceVariableName
-    end
   end
 end

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

@@ -3,8 +3,8 @@ module Textus
     class Check
       class AuditLog < Check
         def call
-          path = Textus::Layout.audit_log(root)
-          Textus::Ports::AuditLog.new(root).verify_integrity.map do |v|
+          path = Textus::Store::Geometry.new(root).audit_log_path
+          Textus::Port::AuditLog.new(root).verify_integrity.map do |v|
             {
               "code" => "audit.parse_error",
               "level" => "warning",

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

@@ -10,8 +10,8 @@ module Textus
         def call
           gen = Textus::Core::Freshness::Evaluator.new(
             manifest: manifest,
-            file_stat: Textus::Ports::Storage::FileStat.new,
-            clock: Textus::Ports::Clock.new,
+            file_stat: Textus::Port::Storage::FileStat.new,
+            clock: Textus::Port::Clock.new,
           )
           manifest.data.entries.flat_map { |m| gen.drift_rows(m) }.map do |row|
             {