textus 0.55.2 → 0.56.0

data/lib/textus/lanes/ingest/resolver.rb

@@ -0,0 +1,21 @@
+module Textus
+  module Lanes
+    module Ingest
+      module Resolver
+        module_function
+
+        def supersede(old_key, new_key, ctx:, call:)
+          old_env = ctx.read(key: old_key)
+          old_content = old_env&.content || {}
+          tombstone = {}
+          %w[ingested_at ingest_count].each { |k| tombstone[k] = old_content[k] if old_content.key?(k) }
+          source_kind = old_content.dig("source", "kind")
+          tombstone["source"] = { "kind" => source_kind } if source_kind
+          tombstone["superseded_by"] = new_key
+
+          ctx.put(key: old_key, meta: {}, body: nil, content: tombstone, call:)
+        end
+      end
+    end
+  end
+end

data/lib/textus/lanes/knowledge/freeform.rb

@@ -0,0 +1,15 @@
+module Textus
+  module Lanes
+    module Knowledge
+      module Freeform
+        def self.entries(manifest)
+          manifest.data.entries.reject { |e| e.key.start_with?("knowledge.loop.") }
+        end
+
+        def self.get(store, key)
+          store.get(key:)
+        end
+      end
+    end
+  end
+end

data/lib/textus/lanes/knowledge/handlers.rb

@@ -0,0 +1,53 @@
+module Textus
+  module Lanes
+    module Knowledge
+      module Handlers
+        module_function
+
+        LOOP_NODE_KEYS = {
+          "intent" => "knowledge.loop.intent",
+          "constraint.repo" => "knowledge.loop.constraint.repo",
+          "constraint.protocol" => "knowledge.loop.constraint.protocol",
+          "judgment.engineering" => "knowledge.loop.judgment.engineering",
+          "judgment.agent-behavior" => "knowledge.loop.judgment.agent-behavior",
+          "evidence" => "knowledge.loop.evidence",
+          "execution" => "knowledge.loop.execution.runbook",
+          "adoption" => "knowledge.loop.adoption",
+        }.freeze
+
+        def loop(ctx:, call:)
+          nodes = LOOP_NODE_KEYS.map { |name, key| { "name" => name, "key" => key } }
+          role = call&.role || "agent"
+          runner = Runner.new(ctx.manifest, cursor_store: ctx.cursor_store)
+          feedback = recent_feedback(ctx)
+          {
+            "loop" => nodes,
+            "count" => nodes.size,
+            "flow" => runner.flow,
+            "current_node" => runner.current_position(role),
+            "feedback" => feedback,
+          }
+        end
+
+        def recent_feedback(ctx)
+          rows = ctx.entry_index&.search(schema: "loop-feedback", lane: "knowledge", query: nil, prefix: nil)
+          return [] unless rows&.any?
+
+          rows.map do |row|
+            env = ctx.read(key: row["key"])
+            meta = env&.meta || {}
+            {
+              "key" => row["key"],
+              "node" => meta["node"],
+              "confidence" => meta["confidence"],
+              "signal" => meta["signal"],
+              "summary" => env&.body || meta["summary"],
+            }
+          end
+        rescue Textus::Error
+          []
+        end
+      end
+    end
+  end
+end

data/lib/textus/lanes/knowledge/runner.rb

@@ -0,0 +1,45 @@
+module Textus
+  module Lanes
+    module Knowledge
+      class Runner
+        def initialize(manifest, cursor_store: nil)
+          @manifest = manifest
+          @cursor_store = cursor_store
+        end
+
+        def loop_nodes
+          @manifest.data.entries.select do |e|
+            e.key.start_with?("knowledge.loop.") && e.key.count(".") == 2
+          end
+        end
+
+        def flow
+          loop_nodes.map { |e| e.key.split(".").last }
+        end
+
+        def current_node(active_index: 0)
+          nodes = loop_nodes
+          return nil if nodes.empty?
+
+          idx = active_index % nodes.size
+          { name: nodes[idx].key.split(".").last, index: idx, total: nodes.size }
+        end
+
+        def advance(active_index: 0)
+          current_node(active_index: active_index + 1).merge(advanced: true)
+        end
+
+        def current_position(role)
+          idx = @cursor_store ? @cursor_store.get_loop(role)[:index] : 0
+          current_node(active_index: idx)
+        end
+
+        def advance_role(role)
+          idx = @cursor_store ? @cursor_store.get_loop(role)[:index] + 1 : 1
+          @cursor_store&.set_loop(role, idx)
+          current_node(active_index: idx).merge(advanced: true)
+        end
+      end
+    end
+  end
+end

data/lib/textus/lanes/knowledge/verbs.rb

@@ -0,0 +1,16 @@
+module Textus
+  module Lanes
+    module Knowledge
+      module Verbs
+      end
+    end
+  end
+end
+
+Textus::Protocol::VerbRegistry.register(
+  Textus::Protocol::VerbRegistry::VerbSpec.new(
+    verb: :loop, summary: "Return the knowledge loop structure — node names and flow order.",
+    args: [], surfaces: %i[cli mcp], category: :read,
+    lane: :knowledge
+  ),
+)

data/lib/textus/lanes/scratchpad/handlers.rb

@@ -0,0 +1,164 @@
+module Textus
+  module Lanes
+    module Scratchpad
+      module Handlers
+        PROPOSALS_PARENT_KEY = "scratchpad.proposals"
+
+        module_function
+
+        SESSION_PARENT_KEY = "scratchpad.sessions"
+
+        def session_open(ctx:, call:)
+          uuid = SecureRandom.uuid
+          key = "scratchpad.sessions.#{uuid}.session"
+
+          content = { "session_id" => uuid, "created_at" => Time.now.utc.iso8601, "status" => "active" }
+          ctx.put(key:, meta: {}, body: JSON.generate(content), content: nil, call:)
+
+          boot = begin
+            Textus::Protocol::Boot.build(container: ctx.container)
+          rescue StandardError
+            nil
+          end
+          result = { "session_id" => uuid, "status" => "active" }
+          result["boot"] = boot if boot
+          result
+        end
+
+        def parent_mentry(ctx)
+          ctx.manifest.data.entries.find { |e| e.key == SESSION_PARENT_KEY }
+        end
+
+        def propose(key:, ctx:, call:, meta: nil, data: nil)
+          body, content = data.is_a?(Hash) ? [nil, data] : [data, nil]
+
+          target_key = meta&.dig("proposal", "target_key")
+          if target_key
+            resolution = ctx.manifest.resolver.resolve(target_key)
+            Textus::Protocol::EntryConstraint.validate_naming!(target_key, resolution.entry)
+          end
+
+          full_key = "#{PROPOSALS_PARENT_KEY}.#{key}"
+          env = ctx.put(key: full_key, meta: meta || {}, body:, content:, call:)
+          env.to_h_for_wire
+        end
+
+        def accept(pending_key:, ctx:, call:, dry_run: false)
+          env = ctx.read(key: pending_key)
+          proposal = env&.meta&.dig("proposal")
+          raise Textus::ProposalError.new("entry has no proposal block: #{pending_key}") unless proposal
+
+          target = proposal["target_key"]
+          raise Textus::ProposalError.new("proposal missing target_key") unless target
+
+          action = proposal["action"] || "put"
+
+          if dry_run
+            target_env = ctx.read(key: target)
+            body_diff = Textus::Protocol::Diff.body(target_env&.body, env.body)
+            meta_diff = Textus::Protocol::Diff.meta(target_env&.meta&.dig("_meta") || {}, env.meta&.dig("_meta") || {})
+            result = { "dry_run" => true, "pending_key" => pending_key, "target_key" => target, "action" => action }
+            result["body"] = body_diff if body_diff
+            result["meta"] = meta_diff if meta_diff
+            result["summary"] = Textus::Protocol::Diff.summary(result)
+            return result
+          end
+
+          case action
+          when "put"
+            target_meta = env.meta.to_h.except("proposal")
+
+            # Parse body frontmatter to extract schema-relevant meta fields
+            resolution = ctx.manifest.resolver.resolve(target)
+            if env.body && !env.body.empty?
+              parsed = Textus::Protocol::Format.for(resolution.entry.format).parse(env.body)
+              body_meta = parsed["_meta"] || {}
+              target_meta = body_meta.merge(target_meta)
+            end
+
+            # Re-validate constraints at promotion time
+            payload = Textus::Value::Payload.new(meta: target_meta, body: env.body, content: env.content)
+            Textus::Protocol::EntryConstraint.validate_naming!(target, resolution.entry)
+            Textus::Protocol::EntryConstraint.validate_schema!(payload, resolution.entry, schemas: ctx.schemas)
+            Textus::Protocol::EntryConstraint.validate_format!(payload, resolution.entry)
+
+            ctx.put(key: target, meta: target_meta, body: env.body, content: env.content, call:)
+          when "delete"
+            ctx.delete(key: target, call:)
+          else
+            raise Textus::ProposalError.new("unknown action: #{action}")
+          end
+
+          ctx.delete(key: pending_key, call:)
+          { "protocol" => Textus::PROTOCOL, "accepted" => pending_key,
+            "target_key" => target, "action" => action, "cascade_key" => target }
+        end
+
+        def reject(pending_key:, ctx:, call:, reason: nil)
+          env = ctx.read(key: pending_key)
+          proposal = env&.meta&.dig("proposal")
+          raise Textus::ProposalError.new("entry has no proposal block: #{pending_key}") unless proposal
+
+          target_key = proposal["target_key"]
+          ctx.delete(key: pending_key, call:)
+          result = { "protocol" => Textus::PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
+          result["reason"] = reason if reason
+          result
+        end
+
+        def diff(pending_key:, ctx:, call:)
+          env = ctx.read(key: pending_key)
+          proposal = env&.meta&.dig("proposal")
+          raise Textus::ProposalError.new("entry has no proposal block: #{pending_key}") unless proposal
+
+          target_key = proposal["target_key"]
+          raise Textus::ProposalError.new("proposal missing target_key") unless target_key
+
+          target_env = ctx.read(key: target_key)
+
+          body_diff = Textus::Protocol::Diff.body(target_env&.body, env.body)
+          meta_diff = Textus::Protocol::Diff.meta(target_env&.meta&.dig("_meta") || {}, env.meta&.dig("_meta") || {})
+
+          entry = ctx.manifest.data.entries.find { |e| e.key == target_key }
+          target_schema = entry&.schema_ref
+          proposal_schema = env&.meta&.dig("_meta", "schema")
+          schema_diff = nil
+          if proposal_schema && target_schema != proposal_schema
+            schema_diff = Textus::Protocol::Diff.schema({ "schema" => target_schema }, { "schema" => proposal_schema })
+          end
+
+          result = { "pending_key" => pending_key, "target_key" => target_key }
+          result["body"] = body_diff if body_diff
+          result["meta"] = meta_diff if meta_diff
+          result["schema"] = schema_diff if schema_diff
+          result["summary"] = Textus::Protocol::Diff.summary(result)
+          result
+        end
+
+        def session_close(session_id:, ctx:, call:, nodes_checked: nil)
+          key = "scratchpad.sessions.#{session_id}.session"
+          env = ctx.read(key:)
+          raise Textus::UsageError.new("session not found: #{session_id}") unless env
+
+          current = JSON.parse(env.body || "{}")
+          content = current.merge("status" => "sealed", "closed_at" => Time.now.utc.iso8601)
+          ctx.put(key:, meta: {}, body: JSON.generate(content), content: nil, call:)
+
+          feedback_key = "scratchpad.sessions.#{session_id}.feedback"
+          duration = current["created_at"] ? "#{((Time.now.utc - Time.parse(current["created_at"])) / 60).round}m" : "unknown"
+          feedback = {
+            "node" => "feedback",
+            "confidence" => "medium",
+            "signal" => "session_closed",
+            "summary" => "Session #{session_id[0..8]} sealed after #{duration}. " \
+                         "Created at #{current["created_at"]}, closed at #{Time.now.utc.iso8601}.",
+          }
+          feedback["nodes_checked"] = nodes_checked if nodes_checked
+          ctx.put(key: feedback_key, meta: {}, body: JSON.generate(feedback), content: nil, call:)
+
+          { "session_id" => session_id, "status" => "sealed", "feedback_key" => feedback_key }
+        end
+      end
+    end
+  end
+end

data/lib/textus/lanes/scratchpad/verbs.rb

@@ -0,0 +1,73 @@
+module Textus
+  module Lanes
+    module Scratchpad
+      module Verbs
+      end
+    end
+  end
+end
+
+Textus::Protocol::VerbRegistry.register(
+  Textus::Protocol::VerbRegistry::VerbSpec.new(
+    verb: :session_open, summary: "Create a new agent session with workspace directories.",
+    args: [], surfaces: %i[cli mcp], category: :write,
+    lane: :scratchpad
+  ),
+)
+Textus::Protocol::VerbRegistry.register(
+  Textus::Protocol::VerbRegistry::VerbSpec.new(
+    verb: :session_close, summary: "Seal an active session by ID.",
+    args: [Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :session_id, required: true,
+                                                       description: "UUID of the session to close"),
+           Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :nodes_checked, type: Array,
+                                                       description: "list of loop nodes checked during the session")],
+    surfaces: %i[cli mcp], category: :write,
+    lane: :scratchpad
+  ),
+)
+
+Textus::Protocol::VerbRegistry.register(
+  Textus::Protocol::VerbRegistry::VerbSpec.new(
+    verb: :propose, summary: "Write a proposal to scratchpad.proposals for human review.",
+    args: [Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :key, required: true, positional: true,
+                                                       description: "key relative to propose_lane, e.g. 'decisions.feature-x'"),
+           Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :meta, type: Hash, wire_name: :_meta,
+                                                       description: "frontmatter. Include a 'proposal:' block naming the target_key"),
+           Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :data,
+                                                       description: "unified payload — String (body) or Hash (content)")],
+    surfaces: %i[cli mcp], category: :write,
+    lane: :scratchpad
+  ),
+)
+Textus::Protocol::VerbRegistry.register(
+  Textus::Protocol::VerbRegistry::VerbSpec.new(
+    verb: :accept, summary: "Apply a scratchpad.proposals entry to its target zone; requires author.",
+    args: [Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :pending_key, required: true, positional: true,
+                                                       description: "the queued proposal's key"),
+           Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :dry_run, type: :boolean, default: false,
+                                                       description: "when true, compute diff without promoting")],
+    surfaces: %i[cli mcp], category: :write,
+    lane: :scratchpad
+  ),
+)
+Textus::Protocol::VerbRegistry.register(
+  Textus::Protocol::VerbRegistry::VerbSpec.new(
+    verb: :reject, summary: "Discard a scratchpad.proposals entry without applying it.",
+    args: [Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :pending_key, required: true, positional: true,
+                                                       description: "the queued proposal's key"),
+           Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :reason,
+                                                       description: "optional explanation for the rejection")],
+    surfaces: %i[cli mcp], category: :write,
+    lane: :scratchpad
+  ),
+)
+Textus::Protocol::VerbRegistry.register(
+  Textus::Protocol::VerbRegistry::VerbSpec.new(
+    verb: :diff, summary: "Preview the diff between a scratchpad.proposals entry and its target.",
+    args: [Textus::Protocol::VerbRegistry::ArgSpec.arg(name: :pending_key, required: true, positional: true,
+                                                       description: "the queued proposal's key")],
+    surfaces: %i[cli mcp],
+    category: :read,
+    lane: :scratchpad
+  ),
+)

data/lib/textus/{dispatch → protocol}/binder.rb

@@ -1,5 +1,5 @@
 module Textus
-  module Dispatch
+  module Protocol
     class MissingArgs < Textus::Error
       attr_reader :spec, :missing
 
@@ -11,14 +11,8 @@ module Textus
     end
 
     module Binder
-      Pending = Data.define(:spec, :inputs)
-
       module_function
 
-      def command(spec, inputs)
-        Pending.new(spec: spec, inputs: inputs)
-      end
-
       def bind(spec, inputs)
         missing = spec.required_args.reject { |a| inputs.key?(a.name) }
         raise MissingArgs.new(spec, missing) unless missing.empty?

data/lib/textus/protocol/boot/catalog.rb

@@ -0,0 +1,34 @@
+module Textus
+  module Protocol
+    module Boot
+      module Catalog
+        CURATED_CLI_VERBS = [
+          { "name" => "boot" },
+          { "name" => "list" },
+          { "name" => "loop" },
+          { "name" => "get" },
+          { "name" => "ingest" },
+          { "name" => "where" },
+          { "name" => "schema", "summary" => "schema operations: 'schema show KEY', 'schema diff', 'schema init', 'schema migrate'" },
+          { "name" => "put" },
+          { "name" => "propose" },
+          { "name" => "accept" },
+          { "name" => "key", "summary" => "key operations: 'key delete', 'key mv', 'key uid'" },
+          { "name" => "drain" },
+          { "name" => "session", "summary" => "session lifecycle: session_open, session_close" },
+          { "name" => "audit" },
+          { "name" => "blame" },
+          { "name" => "pulse" },
+        ].freeze
+
+        def self.build
+          summaries = Textus::Protocol::VerbRegistry.registered.to_h { |s| [s.verb.to_s, s.summary] }
+          CURATED_CLI_VERBS.map do |entry|
+            derived = summaries[entry["name"]]
+            derived ? entry.merge("summary" => derived) : entry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/textus/protocol/boot/context.rb

@@ -0,0 +1,124 @@
+module Textus
+  module Protocol
+    module Boot
+      module Context
+        def self.build(manifest:, event_store:, file_system:, layout:)
+          etag       = Textus::Value::Etag.for_contract(layout)
+          latest_seq = event_store.latest[:seq]
+          artifact   = read_artifact_content(manifest, file_system, layout)
+          context    = read_boot_context(manifest, file_system, layout)
+
+          stable = artifact || inline_boot_content(manifest, latest_seq)
+          if stable["agent_quickstart"]
+            stable = stable.merge(
+              "agent_quickstart" => stable["agent_quickstart"].merge("latest_seq" => latest_seq),
+            )
+          end
+
+          payload = {
+            "protocol" => Textus::PROTOCOL,
+            "store_root" => layout.root,
+            "contract_etag" => etag,
+          }.merge(stable)
+          payload["context"] = context if context
+          payload
+        end
+
+        def self.read_artifact_content(manifest, file_system, _layout)
+          key = "artifacts.boot"
+          res = manifest.resolver.resolve(key)
+          return nil unless res.path && file_system.exists?(res.path)
+
+          mentry = res.entry
+          raw = file_system.read(res.path)
+          parsed = Textus::Protocol::Format.for(mentry.format).parse(raw, path: res.path)
+          parsed["content"]
+        rescue Textus::Error
+          nil
+        end
+
+        def self.read_boot_context(manifest, file_system, _layout)
+          res = manifest.resolver.resolve("knowledge.boot")
+          return nil unless res.path && file_system.exists?(res.path)
+
+          mentry = res.entry
+          raw = file_system.read(res.path)
+          parsed = Textus::Protocol::Format.for(mentry.format).parse(raw, path: res.path)
+          body = parsed["body"]&.strip
+          body.nil? || body.empty? ? nil : body
+        rescue Textus::Error
+          nil
+        end
+
+        def self.inline_boot_content(manifest, _latest_seq)
+          agent_role     = manifest.policy.proposer_role
+          writable_lanes = manifest.data.declared_lane_kinds.keys.each_with_object([]) do |ln, acc|
+            next unless agent_role
+
+            writers = manifest.policy.writers_for(ln)
+            acc << ln if writers.include?(agent_role)
+          end
+
+          author_writers = manifest.policy.writers_for("knowledge")
+          agent_has_author = agent_role && author_writers.include?(agent_role)
+          write_verbs = if agent_role
+                          mcp_verbs = Textus::Protocol::VerbRegistry.registered.select { |s| s.write? && s.mcp? }
+                          unless agent_has_author
+                            forbidden = %i[accept reject].to_set.freeze
+                            mcp_verbs = mcp_verbs.reject { |s| forbidden.include?(s.verb) }
+                          end
+                          mcp_verbs.map { |s| s.verb.to_s }
+                        else
+                          []
+                        end
+
+          meta_glossary = {
+            "knowledge.loop.adoption" => { "node" => "target loop node", "confidence" => "high|medium|low",
+                                           "signal" => "observation type", "summary" => "brief description" },
+            "scratchpad.proposals" => { "proposal" => "{ target_key, action }" },
+            "raw" => { "source" => "{ kind, url, path, label }" },
+          }.freeze
+
+          blueprints = manifest.data.entries.map do |entry|
+            bp = { "key_prefix" => entry.key, "format" => entry.format.to_s, "naming" => entry.naming.to_s }
+            bp["schema"] = entry.schema.to_s if entry.schema
+            meta = meta_glossary[entry.key]
+            bp["meta"] = meta if meta
+            bp
+          end
+
+          {
+            "lanes" => lanes_for(manifest),
+            "entry_blueprints" => blueprints,
+            "workflow_tips" => [
+              { "when" => "write an entry", "then" => "`data` param: String for body, Hash for content" },
+              { "when" => "edit a protected path", "then" => "`textus propose key=my-change data=...` — human reviews and accepts" },
+              { "when" => "explore recent changes", "then" => "`textus pulse` then `textus get <changed_key>`" },
+              { "when" => "find related entries", "then" => "`textus graph key=<key> depth=2`" },
+            ],
+            "agent_quickstart" => {
+              "read_verbs" => Textus::Protocol::VerbRegistry.registered.select { |s| s.read? && s.mcp? }.map { |s| s.verb.to_s },
+              "write_verbs" => write_verbs,
+              "writable_lanes" => writable_lanes,
+              "propose_lane" => manifest.policy.propose_lane_for(agent_role),
+            },
+          }
+        end
+
+        def self.lanes_for(manifest)
+          manifest.data.declared_lane_kinds.keys.map do |name|
+            row = { "name" => name, "writers" => manifest.policy.writers_for(name) }
+            purpose = manifest.data.lane_descs[name]
+            row["purpose"] = purpose if purpose && !purpose.empty?
+            row
+          end
+        end
+
+        class NullEntryIndex
+          def record(...) = nil
+          def remove(...) = nil
+        end
+      end
+    end
+  end
+end

data/lib/textus/protocol/boot/protocol.rb

@@ -0,0 +1,33 @@
+module Textus
+  module Protocol
+    module Boot
+      module Protocol
+        ENVELOPE_SHAPE = {
+          "envelope_shape" => {
+            "summary" => "every read/write payload is a JSON envelope with _meta, body, uid, and etag",
+            "fields" => {
+              "_meta" => "hash of structured frontmatter; schema-validated per entry family",
+              "body" => "string payload (markdown/text) or nil for json/yaml formats",
+              "uid" => "stable 16-char hex identifier; preserved across writes and key renames",
+              "etag" => "content hash; pass back on writes to detect concurrent edits",
+            },
+          },
+        }.freeze
+
+        def self.build(manifest)
+          ENVELOPE_SHAPE.merge(
+            "lanes" => lanes_for(manifest),
+            "roles" => Textus::Protocol::V4::LANES.values.flat_map { |r| r[:writers] }.uniq,
+            "discipline" => "When edit/write tools are blocked for a path, use `textus propose` to " \
+                            "suggest changes for human review. Never use shell scripts (sed, python, rm) " \
+                            "to bypass permission gates — that breaks the audit trail and bypasses role gates.",
+          )
+        end
+
+        def self.lanes_for(manifest)
+          Context.lanes_for(manifest)
+        end
+      end
+    end
+  end
+end

data/lib/textus/protocol/boot.rb

@@ -0,0 +1,42 @@
+require_relative "boot/catalog"
+require_relative "boot/protocol"
+require_relative "boot/context"
+
+module Textus
+  module Protocol
+    module Boot
+      PROTOCOL_ID = PROTOCOL
+      CURATED_CLI_VERBS = Catalog::CURATED_CLI_VERBS
+
+      def self.contract_summaries
+        Textus::Protocol::VerbRegistry.registered.to_h { |s| [s.verb.to_s, s.summary] }
+      end
+
+      def self.build(container:)
+        manifest = container.manifest
+        envelope = Context.build(
+          manifest:,
+          event_store: container.store.audit_log,
+          file_system: container.store.file_system,
+          layout: container.layout,
+        )
+        envelope.merge(
+          "catalog" => Catalog.build,
+          "agent_protocol" => Protocol.build(manifest),
+          "schemas" => build_schemas(container.schemas),
+        )
+      end
+
+      def self.build_schemas(registry)
+        return [] unless registry
+
+        registry.all.map do |s|
+          h = { "name" => s.name, "required" => s.required, "optional" => s.optional }
+          h["fields"] = s.fields unless s.fields.empty?
+          h["evolution"] = s.evolution unless s.evolution.empty?
+          h
+        end
+      end
+    end
+  end
+end

data/lib/textus/protocol/builder/domain.rb

@@ -0,0 +1,17 @@
+module Textus
+  module Protocol
+    class Builder
+      class Domain
+        Components = Data.define(:manifest, :schemas, :workflows, :workflow_registry)
+
+        def call(root, layout:)
+          manifest = Manifest.load(root)
+          schemas = Schema::Registry.new(layout.schemas_dir)
+          workflows = Workflow::Registry.load_all(root)
+          workflow_registry = Workflow::Registry.new(workflows)
+          Components.new(manifest:, schemas:, workflows:, workflow_registry:)
+        end
+      end
+    end
+  end
+end