jazari 0.7.0 → 0.8.1

data/lib/jazari/mcp/stdio_server.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "json"
+require "jazari/version"
+require "jazari/mcp/actions"
+
+module Jazari
+  module Mcp
+    class StdioServer
+      PROTOCOL_VERSION = "2025-11-25"
+      SUPPORTED_VERSIONS = %w[2024-11-05 2025-03-26 2025-06-18 2025-11-25].freeze
+
+      def initialize(dispatcher:, version: Jazari::VERSION)
+        @dispatcher = dispatcher
+        @version = version
+        @initialization_response_sent = false
+        @initialized = false
+      end
+
+      def serve(input: $stdin, output: $stdout)
+        input.each_line do |line|
+          next if line.strip.empty?
+
+          message = JSON.parse(line)
+          response = receive(message)
+          output.puts(JSON.generate(response)) if response
+          output.flush
+        rescue JSON::ParserError
+          output.puts(JSON.generate(jsonrpc_error(nil, -32_700, "Parse error")))
+          output.flush
+        rescue StandardError
+          id = message.is_a?(Hash) ? message["id"] : nil
+          output.puts(JSON.generate(jsonrpc_error(id, -32_603, "Internal error")))
+          output.flush
+        end
+        0
+      end
+
+      def receive(message)
+        id = message.is_a?(Hash) ? message["id"] : nil
+        return jsonrpc_error(id, -32_600, "Invalid Request") unless valid_message?(message)
+        return receive_notification(message) unless message.key?("id")
+
+        case message["method"]
+        when "initialize" then initialize_response(message)
+        when "ping" then empty_response(message)
+        else
+          return jsonrpc_error(message["id"], -32_002, "Server not initialized") unless @initialized
+
+          operational_response(message)
+        end
+      end
+
+      def operational_response(message)
+        case message["method"]
+        when "tools/list" then list_tools(message)
+        when "tools/call" then call_tool(message)
+        else jsonrpc_error(message["id"], -32_601, "Method not found")
+        end
+      end
+
+      private
+
+      def valid_message?(message)
+        message.is_a?(Hash) && message["jsonrpc"] == "2.0" && message["method"].is_a?(String) &&
+          (!message.key?("id") || message["id"].is_a?(String) || message["id"].is_a?(Numeric))
+      end
+
+      def initialize_response(message)
+        return jsonrpc_error(message["id"], -32_600, "Already initialized") if @initialization_response_sent
+        return jsonrpc_error(message["id"], -32_602, "Invalid params") unless valid_initialize_params?(message["params"])
+
+        requested = message.dig("params", "protocolVersion")
+        negotiated = SUPPORTED_VERSIONS.include?(requested) ? requested : PROTOCOL_VERSION
+        @initialization_response_sent = true
+        jsonrpc_result(
+          message["id"],
+          protocolVersion: negotiated,
+          capabilities: { tools: { listChanged: false } },
+          serverInfo: {
+            name: "jazari", title: "Jazari", version: @version,
+            description: "Addressable operating procedures and run evidence."
+          },
+          instructions: "Authorize the caller before constructing a target. Jazari records procedure state; it does not execute commands."
+        )
+      end
+
+      def valid_initialize_params?(params)
+        params.is_a?(Hash) && params["protocolVersion"].is_a?(String) &&
+          params["capabilities"].is_a?(Hash) && params["clientInfo"].is_a?(Hash) &&
+          params.dig("clientInfo", "name").is_a?(String) &&
+          params.dig("clientInfo", "version").is_a?(String)
+      end
+
+      def receive_notification(message)
+        if message["method"] == "notifications/initialized" && @initialization_response_sent
+          @initialized = true
+        end
+        nil
+      end
+
+      def empty_response(message)
+        return jsonrpc_error(message["id"], -32_602, "Invalid params") unless object_params?(message)
+
+        jsonrpc_result(message["id"], {})
+      end
+
+      def list_tools(message)
+        return jsonrpc_error(message["id"], -32_602, "Invalid params") unless object_params?(message)
+
+        jsonrpc_result(message["id"], tools: [ tool ])
+      end
+
+      def object_params?(message)
+        !message.key?("params") || message["params"].is_a?(Hash)
+      end
+
+      def tool
+        {
+          name: "jazari",
+          title: "Jazari procedure state",
+          description: "Resolve or update a procedure and record run evidence.",
+          inputSchema: Actions.input_schema(target_schema: target_schema),
+          annotations: {
+            readOnlyHint: false, destructiveHint: true,
+            idempotentHint: false, openWorldHint: false
+          }
+        }
+      end
+
+      def target_schema
+        {
+          oneOf: [
+            {
+              type: "object", required: %w[kind key recipe_id],
+              properties: {
+                kind: { const: "queue" }, key: { type: "string", minLength: 1 },
+                recipe_id: { type: "string", minLength: 1 },
+                public_reference: { type: "object" }
+              },
+              additionalProperties: false
+            },
+            {
+              type: "object", required: %w[kind scope_type scope_id key recipe_id],
+              properties: {
+                kind: { const: "anchor" }, scope_type: { type: "string", minLength: 1 },
+                scope_id: { type: "integer" }, key: { type: "string", minLength: 1 },
+                recipe_id: { type: "string", minLength: 1 },
+                public_reference: { type: "object" }
+              },
+              additionalProperties: false
+            }
+          ]
+        }
+      end
+
+      def call_tool(message)
+        params = message.fetch("params", {})
+        return jsonrpc_error(message["id"], -32_602, "Unknown tool") unless params["name"] == "jazari"
+
+        arguments = params.fetch("arguments", {})
+        return jsonrpc_error(message["id"], -32_602, "Invalid params") unless arguments.is_a?(Hash)
+
+        action = arguments["action"]
+        target = arguments["target"]
+        action_arguments = arguments.reject { |key, _| %w[action target].include?(key) }
+        response = @dispatcher.call(
+          "protocol" => Protocol::Dispatcher::VERSION,
+          "request_id" => "mcp:#{message.fetch('id')}",
+          "action" => action,
+          "target" => target,
+          "arguments" => action_arguments
+        )
+        result = {
+          content: [ { type: "text", text: JSON.generate(response) } ],
+          structuredContent: response,
+          isError: response["ok"] == false
+        }
+        jsonrpc_result(message["id"], result)
+      rescue KeyError, TypeError
+        jsonrpc_error(message["id"], -32_602, "Invalid params")
+      end
+
+      def jsonrpc_result(id, result) = { jsonrpc: "2.0", id: id, result: result }
+
+      def jsonrpc_error(id, code, message)
+        { jsonrpc: "2.0", id: id, error: { code: code, message: message } }
+      end
+    end
+  end
+end

data/lib/jazari/operations.rb

@@ -142,6 +142,8 @@ module Jazari
         create_custom(target, expected_revision, origin: origin) { |current| yield(current) }
       end
       resolve(target: target)
+    rescue ActiveRecord::StaleObjectError
+      raise RevisionConflict, "another writer changed this runbook first"
     end
     private_class_method :write
 

data/lib/jazari/protocol/dispatcher.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+require "active_record"
+require "jazari"
+require "jazari/mcp/handler"
+
+module Jazari
+  module Protocol
+    class InvalidRequest < StandardError; end
+
+    class Dispatcher
+      VERSION = "jazari/v1"
+      ACTIONS = ([ "capabilities" ] + Mcp::Actions::NAMES).freeze
+      REQUEST_KEYS = %w[protocol request_id action target arguments].freeze
+      DOMAIN_ERRORS = %w[
+        target_not_found invalid_runbook revision_conflict item_not_found
+        item_not_in_snapshot read_only_target run_closed
+      ].freeze
+
+      def initialize(handler: Mcp::Handler.new)
+        @handler = handler
+      end
+
+      def capabilities
+        adapter = Jazari::ApplicationRecord.connection.adapter_name.downcase
+        storage = if adapter.include?("sqlite")
+          "sqlite"
+        elsif adapter.include?("postgres")
+          "postgresql"
+        else
+          raise ActiveRecord::AdapterNotSpecified, "jazari/v1 does not support the #{adapter} adapter"
+        end
+        {
+          protocol: VERSION,
+          storage: storage,
+          transports: storage == "sqlite" ? %w[cli mcp-stdio] : %w[ruby],
+          features: %w[recipes runbooks runs evidence]
+        }
+      end
+
+      def call(input)
+        request = stringify(input)
+        validate_request!(request)
+        action = request.fetch("action")
+        result = if action == "capabilities"
+          capabilities
+        else
+          @handler.call(
+            action: action,
+            target: target_from(request.fetch("target")),
+            arguments: request.fetch("arguments")
+          )
+        end
+
+        envelope(request, result)
+      rescue InvalidRequest => error
+        error_envelope(input, "invalid_request", error.message)
+      rescue ActiveRecord::RecordNotFound
+        error_envelope(input, "target_not_found")
+      rescue ActiveRecord::StatementInvalid => error
+        code = sqlite_busy?(error) ? "storage_busy" : "storage_failure"
+        error_envelope(input, code)
+      rescue StandardError
+        error_envelope(input, "storage_failure")
+      end
+
+      private
+
+      def validate_request!(request)
+        invalid!("request must be an object") unless request.is_a?(Hash)
+        unknown = request.keys - REQUEST_KEYS
+        invalid!("unknown request fields: #{unknown.join(', ')}") if unknown.any?
+        invalid!("protocol must be #{VERSION}") unless request["protocol"] == VERSION
+        invalid!("request_id must be a non-empty string") unless request["request_id"].is_a?(String) && !request["request_id"].empty?
+
+        action = request["action"]
+        invalid!("unknown action #{action.inspect}") unless ACTIONS.include?(action)
+        invalid!("arguments is required") unless request.key?("arguments")
+        arguments = request["arguments"]
+        invalid!("arguments must be an object") unless arguments.is_a?(Hash)
+
+        if action == "capabilities"
+          invalid!("capabilities does not accept a target") if request.key?("target")
+          invalid!("capabilities does not accept arguments") unless arguments.empty?
+          return
+        end
+
+        invalid!("target is required") unless request["target"].is_a?(Hash)
+        validate_arguments!(action, arguments)
+      end
+
+      def validate_arguments!(action, arguments)
+        descriptor = Mcp::Actions.fetch(action)
+        allowed = descriptor.params.keys.map(&:to_s)
+        unknown = arguments.keys - allowed
+        invalid!("unknown #{action} arguments: #{unknown.join(', ')}") if unknown.any?
+        missing = descriptor.required.map(&:to_s) - arguments.keys
+        invalid!("missing #{action} arguments: #{missing.join(', ')}") if missing.any?
+
+        arguments.each do |key, value|
+          validate_type!(key, value, descriptor.params.fetch(key.to_sym))
+        end
+      end
+
+      def validate_type!(key, value, schema)
+        valid = case schema[:type]
+        when "string" then value.is_a?(String)
+        when "integer" then value.is_a?(Integer)
+        when "boolean" then value == true || value == false
+        when "array" then value.is_a?(Array)
+        else true
+        end
+        invalid!("#{key} must be a #{schema[:type]}") unless valid
+        invalid!("#{key} must be #{schema[:const].inspect}") if schema.key?(:const) && value != schema[:const]
+        invalid!("unknown #{key} #{value.inspect}") if schema[:enum] && !schema[:enum].include?(value)
+        invalid!("#{key} must be at least #{schema[:minimum]}") if schema[:minimum] && value < schema[:minimum]
+        validate_value!(key, value)
+      end
+
+      def validate_value!(key, value)
+        case key
+        when "expected_revision", "actor_ref"
+          invalid!("#{key} must not be empty") if value.empty?
+        when "item_id"
+          invalid!("item_id must not be empty") if value.empty?
+        when "run_id"
+          invalid!("run_id must be positive") unless value.positive?
+        when "topic"
+          invalid!("topic must not be empty") if value.empty?
+          invalid!("topic exceeds #{Operations::MAX_TOPIC}") if value.length > Operations::MAX_TOPIC
+        when "description"
+          invalid!("description exceeds #{Operations::MAX_DESCRIPTION}") if value.length > Operations::MAX_DESCRIPTION
+        when "note"
+          invalid!("note exceeds #{Checklist::MAX_TEXT}") if value.length > Checklist::MAX_TEXT
+        when "text"
+          invalid!("text must not be empty") if value.empty?
+          invalid!("text exceeds #{Checklist::MAX_TEXT}") if value.length > Checklist::MAX_TEXT
+        when "checklist"
+          validate_checklist!(value)
+        when "kind"
+          invalid!("unknown evidence kind #{value.inspect}") unless Runs::EVIDENCE_KINDS.include?(value)
+        when "value"
+          invalid!("evidence value exceeds #{Runs::MAX_EVIDENCE}") if value.length > Runs::MAX_EVIDENCE
+        when "outcome"
+          invalid!("unknown outcome #{value.inspect}") unless Run::OUTCOMES.include?(value)
+        when "confirm"
+          invalid!("confirm must be true") unless value
+        end
+      end
+
+      def validate_checklist!(items)
+        items.each do |item|
+          invalid!("checklist items must be objects") unless item.is_a?(Hash)
+          entry = stringify(item)
+          unknown = entry.keys - %w[id text done required]
+          invalid!("unknown checklist fields: #{unknown.join(', ')}") if unknown.any?
+          invalid!("checklist item text is required") unless entry["text"].is_a?(String) && !entry["text"].empty?
+          invalid!("checklist item text exceeds #{Checklist::MAX_TEXT}") if entry["text"].length > Checklist::MAX_TEXT
+          invalid!("checklist item id is invalid") if entry.key?("id") &&
+            (!entry["id"].is_a?(String) || !entry["id"].match?(Checklist::ID_FORMAT))
+          %w[done required].each do |flag|
+            invalid!("checklist item #{flag} must be a boolean") if entry.key?(flag) && ![ true, false ].include?(entry[flag])
+          end
+        end
+      end
+
+      def target_from(target)
+        kind = target["kind"]
+        case kind
+        when "queue"
+          exact_keys!(target, %w[kind key recipe_id public_reference])
+          QueueTarget.new(
+            queue: required_string(target, "key"),
+            recipe_id: required_string(target, "recipe_id"),
+            public_reference: public_reference(target)
+          )
+        when "anchor"
+          exact_keys!(target, %w[kind scope_type scope_id key recipe_id public_reference])
+          scope_type = required_string(target, "scope_type")
+          AnchorTarget.new(
+            scope_type: scope_type,
+            scope_id: required_integer(target, "scope_id"),
+            key: required_string(target, "key"),
+            recipe_id: required_string(target, "recipe_id"),
+            public_reference: public_reference(target)
+          )
+        else
+          invalid!("target kind must be queue or anchor")
+        end
+      end
+
+      def exact_keys!(value, allowed)
+        unknown = value.keys - allowed
+        invalid!("unknown target fields: #{unknown.join(', ')}") if unknown.any?
+      end
+
+      def required_string(value, key)
+        result = value[key]
+        invalid!("target #{key} must be a non-empty string") unless result.is_a?(String) && !result.empty?
+        result
+      end
+
+      def required_integer(value, key)
+        result = value[key]
+        invalid!("target #{key} must be an integer") unless result.is_a?(Integer)
+        result
+      end
+
+      def public_reference(target)
+        fallback_keys = %w[kind scope_type scope_id key]
+        value = target.fetch("public_reference", target.select { |key, _| fallback_keys.include?(key) })
+        invalid!("target public_reference must be an object") unless value.is_a?(Hash)
+        value
+      end
+
+      def envelope(request, result)
+        normalized = normalize(result)
+        if normalized.delete("ok") == false
+          code = normalized.fetch("error")
+          return error_envelope(request, DOMAIN_ERRORS.include?(code) ? code : "storage_failure")
+        end
+
+        normalized["revision"] = normalized["revision"].to_s if normalized.key?("revision")
+        {
+          "protocol" => VERSION,
+          "request_id" => request.fetch("request_id"),
+          "action" => request.fetch("action"),
+          "ok" => true,
+          "result" => normalized
+        }
+      end
+
+      def error_envelope(input, code, detail = nil)
+        request = input.is_a?(Hash) ? stringify(input) : {}
+        error = { "code" => code }
+        error["detail"] = detail.to_s unless detail.to_s.empty?
+        {
+          "protocol" => VERSION,
+          "request_id" => request["request_id"].to_s,
+          "action" => request["action"].to_s,
+          "ok" => false,
+          "error" => error
+        }
+      end
+
+      def normalize(value)
+        case value
+        when Hash then value.to_h { |key, nested| [ key.to_s, normalize(nested) ] }
+        when Array then value.map { |nested| normalize(nested) }
+        when Time then value.utc.iso8601
+        when Date then value.iso8601
+        when NilClass then nil
+        else value.respond_to?(:to_h) ? normalize(value.to_h) : value
+        end
+      end
+
+      def stringify(value)
+        return value unless value.is_a?(Hash)
+        value.to_h { |key, nested| [ key.to_s, nested.is_a?(Hash) ? stringify(nested) : nested ] }
+      end
+
+      def sqlite_busy?(error)
+        error.cause&.class&.name.to_s.include?("Busy") || error.message.include?("database is locked")
+      end
+
+      def invalid!(message) = raise InvalidRequest, message
+    end
+  end
+end

data/lib/jazari/runs.rb

@@ -158,6 +158,8 @@ module Jazari
         record.save!
       end
       record
+    rescue ActiveRecord::StaleObjectError
+      raise RevisionConflict, "another writer changed this run first"
     end
     private_class_method :mutate
 

data/lib/jazari/standalone/database.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Jazari
+  module Standalone
+    module Database
+      TABLES = Jazari::TABLES.keys.freeze
+      BUSY_TIMEOUT = 5_000
+
+      module_function
+
+      def connect!(path)
+        raise ArgumentError, "database path is required" if path.to_s.empty?
+        raise ArgumentError, "standalone storage requires a SQLite file, not :memory:" if path.to_s == ":memory:"
+
+        configure_local_anchors!
+        path = File.expand_path(path.to_s)
+
+        FileUtils.mkdir_p(File.dirname(path))
+        ActiveRecord::Base.establish_connection(
+          adapter: "sqlite3", database: path, timeout: BUSY_TIMEOUT, pool: 5
+        )
+        connection = Jazari::ApplicationRecord.connection
+        connection.execute("PRAGMA foreign_keys = ON")
+        connection.execute("PRAGMA journal_mode = WAL")
+        connection.execute("PRAGMA busy_timeout = #{BUSY_TIMEOUT}")
+        migrate!(connection)
+        connection
+      end
+
+      def migrate!(connection, migration: CreateJazariTables.new)
+        connection.raw_connection.transaction(:immediate) do
+          existing = TABLES.select { |key| connection.data_source_exists?(Jazari.table_name_for(key)) }
+          next if existing.length == TABLES.length
+
+          if existing.any?
+            raise "partial Jazari schema: found #{existing.join(', ')}; refusing an implicit repair"
+          end
+
+          ActiveRecord::Migration.suppress_messages do
+            migration.migrate(:up)
+          end
+        end
+      end
+
+      def configure_local_anchors!
+        Jazari.configure do |config|
+          config.table_prefix = "jazari_"
+          config.table_names = {}
+          config.anchor_scopes = { "local" => nil }
+        end
+      end
+    end
+  end
+end

data/lib/jazari/standalone.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "fileutils"
+require "json"
+require "jazari"
+require "jazari/mcp/handler"
+
+require_relative "../../app/models/jazari/application_record"
+require_relative "../../app/models/jazari/recipe_record"
+require_relative "../../app/models/jazari/runbook"
+require_relative "../../app/models/jazari/anchor"
+require_relative "../../app/models/jazari/run"
+require_relative "../generators/jazari/install/templates/create_jazari_tables"
+require "jazari/standalone/database"
+require "jazari/protocol/dispatcher"
+require "jazari/mcp/stdio_server"
+
+module Jazari
+  module Standalone
+    class App
+      attr_reader :dispatcher
+
+      def initialize(database:, recipes: [])
+        Database.connect!(database)
+        Array(recipes).each do |path|
+          RecipeRegistry.seed!(RecipeFiles.load(path))
+        end
+        @dispatcher = Protocol::Dispatcher.new
+      end
+
+      def call(request) = dispatcher.call(request)
+      def capabilities = dispatcher.capabilities
+    end
+  end
+end

data/lib/jazari/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jazari
-  VERSION = "0.7.0"
+  VERSION = "0.8.1"
 end

data/protocol/v1/capability.schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/nauman/jazari/protocol/v1/capability.schema.json",
+  "title": "Jazari v1 capabilities",
+  "type": "object",
+  "required": ["protocol", "storage", "transports", "features"],
+  "properties": {
+    "protocol": { "const": "jazari/v1" },
+    "storage": { "enum": ["postgresql", "sqlite"] },
+    "transports": {
+      "type": "array",
+      "items": { "enum": ["ruby", "cli", "mcp-stdio"] },
+      "uniqueItems": true
+    },
+    "features": {
+      "type": "array",
+      "items": { "enum": ["recipes", "runbooks", "runs", "evidence"] },
+      "uniqueItems": true
+    }
+  },
+  "additionalProperties": false
+}

data/protocol/v1/error.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/nauman/jazari/protocol/v1/error.schema.json",
+  "title": "Jazari v1 error",
+  "type": "object",
+  "required": ["code"],
+  "properties": {
+    "code": {
+      "enum": [
+        "target_not_found", "invalid_runbook", "revision_conflict",
+        "item_not_found", "item_not_in_snapshot", "read_only_target",
+        "run_closed", "invalid_request", "storage_busy", "storage_failure"
+      ]
+    },
+    "detail": { "type": "string" }
+  },
+  "additionalProperties": false
+}

data/protocol/v1/fixtures/actor-attribution/scenario.json

@@ -0,0 +1,8 @@
+{
+  "schema": "jazari-conformance/v1",
+  "recipes": [{"id":"actor.v1","topic":"Actor","checklist":[{"id":"first","text":"First"}]}],
+  "steps": [
+    {"request":{"protocol":"jazari/v1","request_id":"open","action":"start","target":{"kind":"queue","key":"actor","recipe_id":"actor.v1"},"arguments":{"actor_ref":"agent:fixture"}},"expect":{"ok":true}},
+    {"request":{"protocol":"jazari/v1","request_id":"tick","action":"tick","target":{"kind":"queue","key":"actor","recipe_id":"actor.v1"},"arguments":{"run_id":"$0.result.run_id","expected_revision":"$0.result.revision","item_id":"first","done":true}},"expect":{"ok":true,"result":{"ticks":[{"actor_ref":"agent:fixture"}]}}}
+  ]
+}

data/protocol/v1/fixtures/daily-idempotency/scenario.json

@@ -0,0 +1,8 @@
+{
+  "schema": "jazari-conformance/v1",
+  "recipes": [{"id":"daily.v1","topic":"Daily","run_policy":"once_per_calendar_day","checklist":[{"id":"first","text":"First"}]}],
+  "steps": [
+    {"request":{"protocol":"jazari/v1","request_id":"open-1","action":"start","target":{"kind":"queue","key":"daily","recipe_id":"daily.v1"},"arguments":{"actor_ref":"agent:fixture"}},"expect":{"ok":true,"result":{"created":true,"idempotent_reuse":false}}},
+    {"request":{"protocol":"jazari/v1","request_id":"open-2","action":"start","target":{"kind":"queue","key":"daily","recipe_id":"daily.v1"},"arguments":{"actor_ref":"agent:fixture"}},"expect":{"ok":true,"result":{"created":false,"idempotent_reuse":true}},"equal":[["result.run_id",0,"result.run_id"]]}
+  ]
+}

data/protocol/v1/fixtures/evidence/scenario.json

@@ -0,0 +1,8 @@
+{
+  "schema": "jazari-conformance/v1",
+  "recipes": [{"id":"evidence.v1","topic":"Evidence","checklist":[{"id":"first","text":"First"}]}],
+  "steps": [
+    {"request":{"protocol":"jazari/v1","request_id":"open","action":"start","target":{"kind":"queue","key":"evidence","recipe_id":"evidence.v1"},"arguments":{"actor_ref":"agent:fixture"}},"expect":{"ok":true}},
+    {"request":{"protocol":"jazari/v1","request_id":"evidence","action":"evidence","target":{"kind":"queue","key":"evidence","recipe_id":"evidence.v1"},"arguments":{"run_id":"$0.result.run_id","expected_revision":"$0.result.revision","item_id":"first","kind":"count","value":"4211"}},"expect":{"ok":true,"result":{"evidence":[{"item_id":"first","kind":"count","value":"4211","actor_ref":"agent:fixture"}]}}}
+  ]
+}

data/protocol/v1/fixtures/operator-edit-wins/scenario.json

@@ -0,0 +1,10 @@
+{
+  "schema": "jazari-conformance/v1",
+  "recipes": [{"id":"operator.v1","topic":"Seeded","checklist":[]}],
+  "steps": [
+    {"request":{"protocol":"jazari/v1","request_id":"default","action":"get","target":{"kind":"anchor","scope_type":"local","scope_id":1,"key":"operator","recipe_id":"operator.v1"},"arguments":{}},"expect":{"ok":true,"result":{"state":"default","topic":"Seeded"}}},
+    {"request":{"protocol":"jazari/v1","request_id":"edit","action":"set","target":{"kind":"anchor","scope_type":"local","scope_id":1,"key":"operator","recipe_id":"operator.v1"},"arguments":{"expected_revision":"$0.result.revision","topic":"Operator wording","description":"","checklist":[]}},"expect":{"ok":true,"result":{"state":"custom","topic":"Operator wording"}}},
+    {"setup":{"replace_recipe":{"id":"operator.v1","topic":"New seed","checklist":[]}}},
+    {"request":{"protocol":"jazari/v1","request_id":"get","action":"get","target":{"kind":"anchor","scope_type":"local","scope_id":1,"key":"operator","recipe_id":"operator.v1"},"arguments":{}},"expect":{"ok":true,"result":{"state":"custom","topic":"Operator wording"}}}
+  ]
+}