textus 0.55.1 → 0.55.2

data/lib/textus/surface/mcp/errors.rb

@@ -1,16 +1,6 @@
 module Textus
   module Surface
     module MCP
-      # Audit cursor fell off the keep window. Client should re-boot and
-      # resume from the new latest_seq.
-      class CursorExpired < Textus::Error
-        JSONRPC_CODE = -32_002
-
-        def initialize(message, details: {})
-          super("cursor_expired", message, details: details)
-        end
-      end
-
       # Tool execution failed (validation, authorization, IO). Wraps an
       # underlying Textus::Error or generic StandardError.
       class ToolError < Textus::Error

data/lib/textus/surface/mcp/projector.rb

@@ -0,0 +1,20 @@
+module Textus
+  module Surface
+    module MCP
+      class Projector
+        def initialize(view_key: :default)
+          @view_key = view_key
+        end
+
+        def dispatch(verb_name, inputs:, store:)
+          spec = VerbRegistry.for(verb_name.to_sym)
+          raise Textus::UsageError.new("unknown verb: #{verb_name}") unless spec
+
+          bound = Textus::Dispatch::Binder.inputs_from_wire(spec, inputs)
+          result = store.public_send(verb_name.to_sym, **bound)
+          spec.view(@view_key).call(result, bound)
+        end
+      end
+    end
+  end
+end

data/lib/textus/surface/mcp/server.rb

@@ -11,18 +11,9 @@ module Textus
       # execution to Catalog.
       class Server
         def initialize(store:, role: Textus::Value::Role::DEFAULT, stdin: $stdin, stdout: $stdout)
-          @store  = store
-          @role   = role
+          @store  = store.with_role(role)
           @stdin  = stdin
           @stdout = stdout
-          # Session built eagerly so the contract_etag is captured at server start.
-          # Changes to manifest/hooks/schemas after this point are detected as drift.
-          @session = Textus::Store::Session.new(
-            role: @role,
-            cursor: @store.audit_log.latest_seq,
-            propose_lane: @store.manifest.policy.propose_lane_for(@role),
-            contract_etag: contract_etag_now,
-          )
 
           @sdk = ::MCP::Server.new(
             name: "textus",
@@ -34,7 +25,6 @@ module Textus
           @sdk.resources_read_handler { |params, server_context:| handle_resource_read(params[:uri].to_s, server_context) }
         end
 
-        # Runs the stdio line loop; delegates each JSON line to the SDK.
         def run
           @stdin.each_line do |line|
             line = line.strip
@@ -48,32 +38,28 @@ module Textus
           end
         end
 
-        # Called from every MCP::Tool handler block in Catalog.
-        # The SDK parses JSON with symbolize_names: true — all nested keys are symbols.
-        # Deep-stringify so Catalog.call receives the string-key format it expects.
         def dispatch(verb_name, args, _server_context)
           str_args = deep_stringify_keys(args)
-          @session.check_etag!(contract_etag_now) unless Catalog.read_verbs.include?(verb_name.to_s)
-          result = Catalog.call(verb_name.to_s, session: @session, store: @store, args: str_args)
-          update_session_for(verb_name.to_s)
+          @store.check_etag!(contract_etag_now) unless Catalog.read_verbs.include?(verb_name.to_s)
+          result = Catalog.call(verb_name.to_s, store: @store, args: str_args)
+          @store = @store.advance_cursor(@store.audit_log.latest_seq) if verb_name == :pulse
+          @store = @store.with_role(@store.role) if verb_name == :boot
           ::MCP::Tool::Response.new([{ type: "text", text: JSON.dump(result) }])
         rescue Textus::ContractDrift => e
           raise_handler_error(e.message, Textus::ContractDrift::JSONRPC_CODE)
-        rescue CursorExpired => e
-          raise_handler_error(e.message, CursorExpired::JSONRPC_CODE)
+        rescue Textus::CursorExpired => e
+          raise_handler_error(e.message, Textus::CursorExpired::JSONRPC_CODE)
         rescue Textus::Surface::MCP::ToolError => e
           raise_handler_error(e.message, ToolError::JSONRPC_CODE)
         rescue StandardError => e
-          raise_handler_error("internal: #{e.class}: #{e.message}", -32_603)
+          raise_handler_error("internal: #{e.message}", -32_603)
         end
 
         private
 
-        def update_session_for(verb_name)
-          @session = @session.advance_cursor(@store.audit_log.latest_seq) if verb_name == "pulse"
-          @session = @session.with(contract_etag: contract_etag_now)      if verb_name == "boot"
-        end
-
+        # Snapshot at server init against the boot-time manifest. New produced entries
+        # added by a later reconcile are invisible until the server restarts — this is
+        # intentional: a ContractDrift will gate writes on any mid-session manifest change.
         def build_resources
           machine_lane = @store.manifest.policy.machine_lane
           return [] unless machine_lane
@@ -84,13 +70,15 @@ module Textus
         end
 
         def handle_resource_read(uri, _server_context)
-          key = uri.delete_prefix("textus://").tr("/", ".")
-          env  = @store.as(@role).get(key)
+          key  = uri.delete_prefix("textus://").tr("/", ".")
+          env  = @store.get(key:)
           text = env.content.is_a?(Hash) ? JSON.dump(env.content) : (env.body || "").to_s
-          mime = mime_for_format(@store.manifest.resolver.resolve(key).entry.format)
+          mime = mime_for_format(env.format)
           [{ uri: uri, mimeType: mime, text: text }]
         rescue Textus::Error => e
           raise_handler_error("resource read failed: #{e.message}", -32_603)
+        rescue StandardError => e
+          raise_handler_error("internal: #{e.message}", -32_603)
         end
 
         def contract_etag_now = Textus::Value::Etag.for_contract(@store.root)
@@ -107,9 +95,10 @@ module Textus
 
         def mime_for_format(format)
           case format.to_s
-          when "json" then "application/json"
-          when "yaml" then "application/yaml"
-          else             "text/plain"
+          when "json"     then "application/json"
+          when "yaml"     then "application/yaml"
+          when "markdown" then "text/markdown"
+          else                 "text/plain"
           end
         end
 

data/lib/textus/{core → value}/duration.rb

@@ -1,8 +1,5 @@
 module Textus
-  module Core
-    # Parses a duration value into whole seconds. Accepts a bare integer (or
-    # integer-string) of seconds, or `<n><unit>` with unit s/m/h/d. Returns
-    # nil for nil or any unparseable value.
+  module Value
     module Duration
       UNIT_SECONDS = { "s" => 1, "m" => 60, "h" => 3600, "d" => 86_400 }.freeze
 

data/lib/textus/value/envelope.rb

@@ -13,16 +13,14 @@ module Textus
       attribute :format,     Types::FormatName
       attribute :etag,       Types::String
       attribute :uid,        Types::String.optional
-      attribute :sources,    Types::Array.of(Types::String).optional
+      attribute :sources,    Types::Array.of(Types::Any).optional
       attribute :schema_ref, Types::String.optional
       attribute :meta,       Types::Hash.default({}.freeze)
       attribute :body,       Types::String.optional
       attribute :content,    Types::Any.optional
       attribute :freshness,  Types::Any.optional
 
-      # rubocop:disable Metrics/ParameterLists
       def self.build(key:, mentry:, path:, meta:, body:, etag:, content: nil, freshness: nil)
-        # rubocop:enable Metrics/ParameterLists
         new(
           protocol: Textus::PROTOCOL,
           key: key,
@@ -48,7 +46,10 @@ module Textus
 
       def self.extract_sources(meta)
         v = meta.is_a?(Hash) ? meta["sources"] : nil
-        v.is_a?(Array) && !v.empty? ? v : nil
+        return nil unless v.is_a?(Array) && !v.empty?
+
+        valid = v.select { |s| s.is_a?(String) || (s.is_a?(Hash) && s["key"].is_a?(String)) }
+        valid.empty? ? nil : valid
       end
 
       def with(**attrs) = self.class.new(to_h.merge(attrs))

data/lib/textus/value/etag.rb

@@ -27,7 +27,7 @@ module Textus
       # manifest.yaml, then every hook and schema file. Dir.glob already returns
       # sorted paths (Ruby 3.0+), keeping the digest independent of FS order.
       def self.contract_files(root)
-        geom = Textus::Store::Geometry.new(root)
+        geom = Textus::Store::Layout.new(root)
         [
           geom.manifest_path,
           *Dir.glob(File.join(geom.hooks_dir, "**", "*.rb")),

data/lib/textus/value/payload.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Textus
+  module Value
+    Payload = Data.define(:meta, :body, :content)
+  end
+end

data/lib/textus/value/result.rb

@@ -1,26 +1,46 @@
-# frozen_string_literal: true
-
 module Textus
   module Value
-    # Unwraps Dry::Monads results at the Gate seam.
-    # Every action returns Success(value) or Failure(code:, message:, details:).
-    # This module converts Failure into an ActionError for surfaces (CLI, MCP)
-    # that expect exceptions.
-    module Result
-      def self.unwrap(result)
+    # rubocop:disable Lint/ConstantDefinitionInBlock
+    Result = Data.define(:ok, :value, :error) do
+      def self.success(value) = new(ok: true, value: value, error: nil)
+
+      def self.failure(code, message, details: {})
+        new(ok: false, value: nil, error: { code: code, message: message, details: details })
+      end
+
+      def self.extract(result)
         case result
-        when Dry::Monads::Result::Success then result.value!
-        when Dry::Monads::Result::Failure
-          failure = result.failure
-          raise ActionError.new(
-            failure[:code] || :internal,
-            failure[:message] || "action failed",
-            details: failure[:details] || {},
-          )
+        when self
+          if result.success?
+            result.value
+          else
+            err = result.error
+            raise Textus::ActionError.new(err[:code] || :error, err[:message] || "action failed", details: err[:details] || {})
+          end
         else
           result
         end
       end
+
+      def success? = ok
+      def failure? = !ok
+
+      def unwrap
+        raise Result::UnwrapError.new(error[:code], error[:message], details: error[:details]) unless ok
+
+        value
+      end
+
+      class UnwrapError < StandardError
+        attr_reader :code, :details
+
+        def initialize(code, message, details: {})
+          super(message)
+          @code = code
+          @details = details
+        end
+      end
     end
+    # rubocop:enable Lint/ConstantDefinitionInBlock
   end
 end