mirrors-sdk 0.1.0

data/test/capture_test.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "timeout"
+
+class CaptureTest < Minitest::Test
+  Settings = Struct.new(:agent_id, :timeout_ms)
+
+  class ScriptedTransport
+    attr_reader :calls
+
+    def initialize(&handler)
+      @calls, @handler, @lock = [], handler, Mutex.new
+    end
+
+    def request(endpoint, body, deadline:, cancel: nil, final_recovery: false)
+      @lock.synchronize { @calls << [endpoint, body, deadline, final_recovery] }
+      request = JSON.parse(body)
+      value = @handler ? @handler.call(request, cancel) : CaptureTest.response(request)
+      raise MirrorsSDK::TransportError.new("transport", permanent: true) unless yield(value)
+      value
+    end
+  end
+
+  def self.response(request)
+    result = {
+      "protocol" => 3, "agentId" => request["agentId"], "traceId" => request["trace"]["id"],
+      "requestId" => request["requestId"], "ordinal" => request["ordinal"], "final" => request["final"],
+      "captureOnly" => true, "decisionId" => "receipt", "expiresAt" => "2026-01-01T00:00:00.000Z",
+      "mode" => "off", "role" => "system", "context" => nil,
+      "ingestion" => request["final"] ? { "status" => "queued", "jobId" => "job" } : nil
+    }
+    result["terminal"] = request["terminal"] if request.key?("terminal")
+    result
+  end
+
+  def input(id = "run", final: false, text: "original", **fields)
+    value = {
+      "trace" => { "id" => id, "messages" => [{ "role" => "user", "content" => text }] }.merge(fields.transform_keys(&:to_s)),
+      "final" => final, "captureOnly" => true
+    }
+    value["terminal"] = "completed" if final
+    value
+  end
+
+  def runtime(transport = ScriptedTransport.new)
+    MirrorsSDK::CaptureRuntime.new(transport, Settings.new("agent", nil))
+  end
+
+  def now
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def send_capture(runtime, value, timeout: 2, cancel: nil)
+    runtime.send(value, deadline: now + timeout, cancel: cancel)
+  end
+
+  def wait_for(&condition)
+    Timeout.timeout(2) { sleep(0.001) until condition.call }
+  end
+
+  def test_owned_identity_and_advancing_ordinals
+    transport = ScriptedTransport.new
+    capture = runtime(transport)
+    %w[first second].each { |text| assert_equal "accepted", send_capture(capture, input(text: text)).status }
+    requests = transport.calls.map { |call| JSON.parse(call[1]) }
+    assert_equal [1, 2], requests.map { |request| request["ordinal"] }
+    refute_equal requests[0]["requestId"], requests[1]["requestId"]
+    assert requests.all? { |request| request["captureOnly"] && request["agentId"] == "agent" }
+  end
+
+  def test_uncertain_write_reconciles_exact_bytes_before_changed_evidence
+    count = 0
+    transport = ScriptedTransport.new do |request, _|
+      count += 1
+      raise MirrorsSDK::TransportError.new("transport") if count == 1
+      self.class.response(request)
+    end
+    capture = runtime(transport)
+    first = input(text: "one")
+    assert_equal "unconfirmed", send_capture(capture, first).status
+    first["trace"]["messages"][0]["content"] = "mutated"
+    assert_equal "accepted", send_capture(capture, input(text: "two")).status
+    assert_equal transport.calls[0][1], transport.calls[1][1]
+    assert_equal "one", JSON.parse(transport.calls[1][1])["trace"]["messages"][0]["content"]
+    assert_equal 2, JSON.parse(transport.calls[2][1])["ordinal"]
+    assert_equal transport.calls[1][2], transport.calls[2][2]
+  end
+
+  def test_failed_reconciliation_never_sends_new_evidence
+    transport = ScriptedTransport.new { raise MirrorsSDK::TransportError.new("transport") }
+    capture = runtime(transport)
+    send_capture(capture, input(text: "one"))
+    send_capture(capture, input(text: "two"))
+    assert_equal 2, transport.calls.length
+    assert_equal transport.calls[0][1], transport.calls[1][1]
+  end
+
+  def test_final_retries_once_and_retains_immutable_receipt
+    count = 0
+    transport = ScriptedTransport.new do |request, _|
+      count += 1
+      raise MirrorsSDK::TransportError.new("transport") if count == 1
+      self.class.response(request)
+    end
+    capture = runtime(transport)
+    receipt = send_capture(capture, input(final: true))
+    assert_equal "accepted", receipt.status
+    assert_equal transport.calls[0], transport.calls[1]
+    assert_equal({ "status" => "queued", "jobId" => "job" }, receipt.ingestion)
+    assert_same receipt, send_capture(capture, input(final: true))
+    assert_equal "terminal_conflict", send_capture(capture, input(final: true, text: "different")).reason
+    assert_equal 2, transport.calls.length
+  end
+
+  def test_permanent_failure_does_not_retry_and_releases_final_capacity
+    transport = ScriptedTransport.new { raise MirrorsSDK::TransportError.new("transport", permanent: true) }
+    capture = runtime(transport)
+    140.times do |index|
+      assert_equal "unconfirmed", send_capture(capture, input("final-#{index}", final: true)).status
+    end
+    assert_equal 140, transport.calls.length
+    assert_equal({ active: 0, terminal: 0, recent: 128 }, capture.diagnostics)
+  end
+
+  def test_metadata_is_fixed_but_final_user_and_latency_may_change
+    transport = ScriptedTransport.new
+    capture = runtime(transport)
+    assert_equal "accepted", send_capture(capture, input(model: "a", user: { "id" => "first" })).status
+    assert_equal "invalid_evidence", send_capture(capture, input(model: "b")).reason
+    result = send_capture(capture, input(final: true, model: "a", user: { "id" => "second" }, turnLatencyMs: 0))
+    assert_equal "accepted", result.status
+    assert_equal 2, transport.calls.length
+  end
+
+  def test_metadata_key_order_has_no_semantic_effect
+    capture = runtime
+    flags = { "ended" => "unknown", "history" => "truncated", "original_content" => "partial" }
+    assert_equal "accepted", send_capture(capture, input(completeness: flags)).status
+    assert_equal "accepted", send_capture(capture, input(completeness: flags.to_a.reverse.to_h)).status
+  end
+
+  def test_prefix_capacity_is_independent_from_finals
+    capture = runtime
+    64.times { |i| assert_equal "accepted", send_capture(capture, input("run-#{i}")).status }
+    assert_equal "capacity", send_capture(capture, input("overflow")).reason
+    assert_equal "accepted", send_capture(capture, input("final-only", final: true)).status
+  end
+
+  def test_invalid_metadata_final_releases_prefix_state
+    capture = runtime
+    send_capture(capture, input(model: "original"))
+    assert_equal "invalid_evidence", send_capture(capture, input(final: true, model: "changed")).reason
+    assert_equal 0, capture.diagnostics[:active]
+  end
+
+  def test_same_trace_serializes_without_blocking_other_traces
+    gate = Queue.new
+    transport = ScriptedTransport.new do |request, _|
+      gate.pop if request["trace"]["id"] == "run" && request["ordinal"] == 1
+      self.class.response(request)
+    end
+    capture = runtime(transport)
+    first = Thread.new { send_capture(capture, input) }
+    wait_for { transport.calls.length == 1 }
+    second = Thread.new { send_capture(capture, input(text: "second")) }
+    assert_equal "accepted", send_capture(capture, input("other")).status
+    assert_equal 2, transport.calls.length
+    gate << true
+    assert_equal "accepted", first.value.status
+    assert_equal "accepted", second.value.status
+    assert_equal 2, JSON.parse(transport.calls.last[1])["ordinal"]
+  ensure
+    gate << true if gate
+    [first, second].compact.each { |thread| thread.join(2) }
+  end
+
+  def test_waiting_for_trace_respects_call_deadline
+    gate = Queue.new
+    transport = ScriptedTransport.new do |request, _|
+      gate.pop
+      self.class.response(request)
+    end
+    capture = runtime(transport)
+    first = Thread.new { send_capture(capture, input) }
+    wait_for { transport.calls.length == 1 }
+    assert_equal "timeout", send_capture(capture, input(text: "queued"), timeout: 0.02).reason
+    assert_equal 1, transport.calls.length
+  ensure
+    gate << true if gate
+    first.join(2) if first
+  end
+
+  def test_release_cancels_prefix_but_preserves_admitted_final
+    transport = ScriptedTransport.new do |_request, cancel|
+      sleep(0.001) until cancel.canceled?
+      raise MirrorsSDK::TransportError.new("canceled")
+    end
+    capture = runtime(transport)
+    prefix = Thread.new { send_capture(capture, input) }
+    wait_for { transport.calls.length == 1 }
+    capture.release("run")
+    assert_equal "unconfirmed", prefix.value.status
+    capture.clear
+    assert_equal "closed", send_capture(capture, input("next")).reason
+  ensure
+    capture.clear if capture
+    prefix.join(2) if prefix
+  end
+
+  def test_final_seals_before_waiting_and_release_keeps_upload
+    gate = Queue.new
+    transport = ScriptedTransport.new do |request, _|
+      gate.pop
+      self.class.response(request)
+    end
+    capture = runtime(transport)
+    prefix = Thread.new { send_capture(capture, input) }
+    wait_for { transport.calls.length == 1 }
+    final = Thread.new { send_capture(capture, input(final: true)) }
+    wait_for { capture.diagnostics[:terminal] == 1 }
+    assert_equal "terminal_conflict", send_capture(capture, input(text: "late")).reason
+    capture.release("run")
+    gate << true
+    assert_equal "accepted", prefix.value.status
+    wait_for { transport.calls.length == 2 }
+    gate << true
+    assert_equal "accepted", final.value.status
+  ensure
+    2.times { gate << true } if gate
+    [prefix, final].compact.each { |thread| thread.join(2) }
+  end
+
+  def test_final_recovery_applies_to_uncertain_prefix_and_new_final
+    count = 0
+    transport = ScriptedTransport.new do |request, _|
+      count += 1
+      raise MirrorsSDK::TransportError.new("transport") if count == 1
+      self.class.response(request)
+    end
+    capture = runtime(transport)
+    send_capture(capture, input)
+    assert_equal "accepted", send_capture(capture, input(final: true)).status
+    assert_equal [false, true, true], transport.calls.map(&:last)
+    assert_equal transport.calls[0][1], transport.calls[1][1]
+    assert_equal 2, JSON.parse(transport.calls.last[1])["ordinal"]
+  end
+
+  def test_host_sequence_supersedes_unsent_older_snapshot
+    transport = ScriptedTransport.new
+    capture = runtime(transport)
+    newer = capture.send(input(text: "newer"), deadline: now + 2, sequence: 2)
+    older = capture.send(input(text: "older"), deadline: now + 2, sequence: 1)
+    assert_equal "accepted", newer.status
+    assert_equal "superseded", older.reason
+    assert_equal 1, transport.calls.length
+    final = capture.send(input(final: true), deadline: now + 2, sequence: 3)
+    assert_equal "accepted", final.status
+    assert_equal 2, JSON.parse(transport.calls.last[1])["ordinal"]
+  end
+
+  def test_caller_cancellation_does_not_poison_execution_state
+    transport = ScriptedTransport.new
+    capture = runtime(transport)
+    cancellation = MirrorsSDK::Cancellation.new
+    cancellation.cancel("canceled")
+    assert_equal "unconfirmed", send_capture(capture, input, cancel: cancellation).status
+    assert_empty transport.calls
+    assert_equal "accepted", send_capture(capture, input(text: "retry")).status
+  end
+
+  def test_terminal_capacity_is_bounded_and_rejected_final_releases_prefix
+    gate = Queue.new
+    transport = ScriptedTransport.new do |request, _|
+      gate.pop if request["final"]
+      self.class.response(request)
+    end
+    capture = runtime(transport)
+    send_capture(capture, input("prefix"))
+    finals = 16.times.map do |index|
+      Thread.new { send_capture(capture, input("final-#{index}", final: true)) }
+    end
+    wait_for { capture.diagnostics[:terminal] == 16 }
+    assert_equal "capacity", send_capture(capture, input("prefix", final: true)).reason
+    assert_equal 0, capture.diagnostics[:active]
+    assert_equal "terminal_conflict", send_capture(capture, input("final-0", final: true, text: "changed")).reason
+    assert_equal 16, capture.diagnostics[:terminal]
+    16.times { gate << true }
+    assert finals.all? { |thread| thread.value.status == "accepted" }
+  ensure
+    16.times { gate << true } if gate
+    finals&.each { |thread| thread.join(2) }
+  end
+
+  def test_capture_ordinal_stops_at_contract_limit
+    transport = ScriptedTransport.new
+    capture = runtime(transport)
+    send_capture(capture, input)
+    capture.instance_variable_get(:@active)["run"].ordinal = 10_000
+    assert_equal "capacity", send_capture(capture, input(text: "next")).reason
+    assert_equal 1, transport.calls.length
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "mirrors_sdk/configuration"
+
+class ConfigurationTest < Minitest::Test
+  def config(**options)
+    MirrorsSDK::Config.new(**{ api_url: "https://example.invalid", api_key: "fixture-key", agent_id: "agent" }.merge(options))
+  end
+
+  def test_copies_and_freezes_settings_and_hides_credentials
+    key = +"secret-fixture"
+    value = config(api_key: key)
+    key.replace("modified")
+    assert_equal "secret-fixture", value.api_key
+    assert value.frozen?
+    assert value.api_key.frozen?
+    refute_includes value.inspect, "secret-fixture"
+    assert_equal 1000, value.heartbeat_interval_ms
+  end
+
+  def test_only_https_and_literal_loopback_http_are_allowed
+    ["https://example.invalid/api", "http://localhost:8000", "http://127.0.0.1:8000", "http://[::1]:8000"].each do |url|
+      assert_equal url, config(api_url: url).api_url
+    end
+    ["http://example.invalid", "http://127.1", "https://user:pass@example.invalid", "https://example.invalid?x",
+     "https://example.invalid#x", "https://example.invalid\\x", "https://example.invalid:99999", "https://example.invalid/\n"].each do |url|
+      assert_raises(ArgumentError) { config(api_url: url) }
+    end
+  end
+
+  def test_invalid_numeric_options_flags_and_credentials_are_rejected
+    [{ timeout_ms: 0 }, { timeout_ms: 30_001 }, { timeout_ms: 1.0 }, { failure_threshold: 0 },
+     { cooldown_ms: 300_001 }, { enabled: 1 }, { heartbeat_interval_ms: 19 }, { mode_lease_ms: 3001 },
+     { heartbeat_interval_ms: 200, mode_lease_ms: 200 }, { api_key: "key\n" }, { api_key: "" },
+     { agent_id: "bad/id" }].each do |options|
+      assert_raises(ArgumentError) { config(**options) }
+    end
+  end
+
+  def test_custom_options_cannot_invoke_comparison_or_string_hooks
+    hostile = Object.new
+    def hostile.==(*)
+      raise "comparison hook"
+    end
+    def hostile.instance_of?(*)
+      raise "type hook"
+    end
+    def hostile.nil?
+      raise "nil hook"
+    end
+    [:enabled, :timeout_ms, :api_url, :api_key, :agent_id].each do |option|
+      assert_raises(ArgumentError) { config(**{ option => hostile }) }
+    end
+    key = +"fixture-key"
+    def key.bytesize
+      raise "string hook"
+    end
+    def key.match?(*)
+      raise "string hook"
+    end
+    assert_equal "fixture-key", config(api_key: key).api_key
+  end
+end

data/test/context_test.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "time"
+
+class ContextTest < Minitest::Test
+  class ManualExecutor
+    attr_reader :jobs
+
+    def initialize
+      @jobs = []
+    end
+
+    def submit(&block)
+      future = MirrorsSDK::Future.new
+      @jobs << [future, block]
+      future
+    end
+  end
+
+  class ClockedHost < MirrorsSDK::ContextHost
+    attr_accessor :monotonic_offset, :wall_offset
+
+    def initialize(*args)
+      super
+      @monotonic_offset = @wall_offset = 0
+    end
+
+    private
+
+    def now
+      super + @monotonic_offset
+    end
+
+    def wall
+      super + @wall_offset
+    end
+  end
+
+  def setup
+    @config = MirrorsSDK::Config.new(api_url: "https://example.invalid", api_key: "test", agent_id: "agent")
+    @executor = ManualExecutor.new
+    @host = ClockedHost.new(@config, Object.new, @executor)
+  end
+
+  def teardown
+    @host.stop
+  end
+
+  def lease(mode = "active", version: "v1", duration: 3000, offset: 0)
+    issued = Time.now.utc + offset / 1000.0
+    { "protocol" => 1, "agentId" => "agent", "mode" => mode, "version" => version,
+      "issuedAt" => issued.iso8601(3), "expiresAt" => (issued + duration / 1000.0).iso8601(3) }
+  end
+
+  def stamp(offset = 0)
+    (Time.now.utc + offset / 1000.0).iso8601(3)
+  end
+
+  def activate
+    @host.observe_mode(lease, monotonic)
+  end
+
+  def start(id = "execution", timeout_ms: 1000)
+    @host.start(trace(id), timeout_ms: timeout_ms, started: monotonic)
+  end
+
+  def accept(wait, changes = {})
+    value = { "protocol" => 1, "agentId" => "agent", "traceId" => wait.trace_id,
+              "requestId" => wait.identifier, "decisionId" => "decision", "modeVersion" => "v1",
+              "issuedAt" => stamp, "expiresAt" => stamp(4000), "mode" => "active",
+              "role" => "system", "context" => "Check the account.", "reason" => "matched" }.merge(changes)
+    wait.job.resolve(value)
+    value
+  end
+
+  def test_unknown_off_and_expired_modes_do_not_schedule_requests
+    assert_equal "mode_unknown", @host.get(trace).reason
+    @host.observe_mode(lease("off"), monotonic)
+    assert_equal "off", @host.get(trace).reason
+    @host.observe_mode(lease("active", duration: 50), monotonic - 0.1)
+    assert_equal "mode_expired", @host.get(trace).reason
+    assert_empty @executor.jobs
+  end
+
+  def test_active_result_is_bound_to_request_and_releases_capacity_at_return
+    activate
+    wait = start
+    value = accept(wait)
+    assert_equal 1, @host.diagnostics[:pending_context]
+    result = @host.await(wait)
+    assert_equal "accepted", result.delivery
+    assert_equal "Check the account.", result.context
+    assert_equal value["requestId"], result.freshness.request_id
+    assert_equal value["expiresAt"], result.freshness.expires_at
+    assert_equal 0, @host.diagnostics[:pending_context]
+    assert_operator result.elapsed_ms, :>=, 0
+    assert_equal "superseded", @host.await(wait).reason
+  end
+
+  def test_ready_decision_is_rechecked_when_the_caller_resumes
+    activate
+    wait = start
+    accept(wait)
+    @host.monotonic_offset = 1.01
+    result = @host.await(wait)
+    assert_equal "timeout", result.reason
+    assert_empty result.context
+    assert_operator result.elapsed_ms, :>=, 1000
+  end
+
+  def test_context_lifetime_cannot_gain_time_from_clock_offset
+    activate
+    wait = start
+    @host.monotonic_offset = 0.02
+    accept(wait, "issuedAt" => stamp(100), "expiresAt" => stamp(101))
+    assert_equal "expired", @host.await(wait).reason
+  end
+
+  def test_mode_expiry_checks_wall_clock_and_request_start_monotonic_lifetime
+    @host.observe_mode(lease(duration: 50, offset: 100), monotonic)
+    @host.wall_offset = -10
+    @host.monotonic_offset = 0.06
+    assert_equal "mode_expired", @host.get(trace).reason
+
+    @host.monotonic_offset = @host.wall_offset = 0
+    activate
+    @host.wall_offset = 10
+    result = @host.get(trace)
+    assert_equal "mode_expired", result.reason
+    assert_equal "shadow", result.mode
+  end
+
+  def test_lease_configuration_and_invalid_request_anchors_cannot_extend_mode
+    activate
+    [Float::NAN, Float::INFINITY, true, monotonic + 1].each do |invalid|
+      @host.observe_mode(lease("off", version: "v2"), invalid)
+      assert_equal "active", @host.diagnostics[:mode]
+    end
+    @host.monotonic_offset = 3.1
+    assert_equal "mode_expired", @host.get(trace).reason
+  end
+
+  def test_shadow_returns_immediately_but_retains_bounded_background_work
+    @host.observe_mode(lease("shadow"), monotonic)
+    wait = start
+    result = @host.await(wait)
+    assert_equal "shadow", result.reason
+    assert_empty result.context
+    assert_equal 1, @executor.jobs.length
+    assert_equal 1, @host.diagnostics[:pending_context]
+    accept(wait)
+    assert_equal 0, @host.diagnostics[:pending_context]
+    assert_empty @host.await(wait).context
+  end
+
+  def test_context_work_carries_shadow_only_and_full_copied_evidence
+    @host.observe_mode(lease("shadow"), monotonic)
+    transport = Object.new
+    requests = []
+    transport.define_singleton_method(:request) do |endpoint, body, **_options, &_validator|
+      requests << [endpoint, JSON.parse(body)]
+      {}
+    end
+    @host = ClockedHost.new(@config, transport, @executor)
+    @host.observe_mode(lease("shadow"), monotonic)
+    original = trace
+    wait = @host.start(original, started: monotonic)
+    original["messages"][0]["content"] = "mutated"
+    @executor.jobs.last[1].call(MirrorsSDK::Cancellation.new)
+    assert_equal "retrieve-context", requests[0][0]
+    assert_equal true, requests[0][1]["shadowOnly"]
+    assert_equal "Hello", requests[0][1]["trace"]["messages"][0]["content"]
+    assert_equal wait.identifier, requests[0][1]["requestId"]
+  end
+
+  def test_new_retrieval_and_changed_capture_invalidate_older_decisions
+    activate
+    first = start
+    second = start
+    assert_equal "superseded", @host.await(first).reason
+    @host.observe("execution", MirrorsSDK::Wire.encode(trace))
+    refute second.job.done?
+    changed = trace
+    changed["messages"] << { "role" => "assistant", "content" => "Done" }
+    @host.observe("execution", MirrorsSDK::Wire.encode(changed))
+    assert_equal "superseded", @host.await(second).reason
+  end
+
+  def test_release_disable_shutdown_and_mode_change_invalidate_ready_results
+    actions = [
+      ["execution_closed", -> { @host.release("execution") }],
+      ["disabled", -> { @host.set_enabled(false) }],
+      ["closed", -> { @host.stop }],
+      ["mode_changed", -> { @host.observe_mode(lease("active", version: "v2"), monotonic) }]
+    ]
+    actions.each do |reason, action|
+      @host = ClockedHost.new(@config, Object.new, @executor)
+      activate
+      wait = start
+      accept(wait)
+      action.call
+      assert_equal reason, @host.await(wait).reason
+      assert_equal 0, @host.diagnostics[:pending_context]
+    end
+  end
+
+  def test_retrieval_capacity_includes_accepted_unconsumed_results
+    activate
+    waits = 16.times.map { |index| start("execution-#{index}") }
+    waits.each { |wait| accept(wait) }
+    assert_equal "capacity", @host.get(trace("overflow")).reason
+    assert_equal 16, @executor.jobs.length
+    @host.await(waits.first)
+    start("replacement")
+    assert_equal 16, @host.diagnostics[:pending_context]
+    assert_equal 17, @executor.jobs.length
+  end
+
+  def test_total_deadline_includes_time_before_preparation
+    activate
+    wait = @host.start(trace, timeout_ms: 20, started: monotonic - 0.03)
+    assert_equal "timeout", @host.await(wait).reason
+    assert_empty @executor.jobs
+  end
+
+  def test_wait_timeout_and_cancellation_cancel_transport_without_reusing_late_results
+    activate
+    wait = start(timeout_ms: 20)
+    assert_equal "timeout", @host.await(wait).reason
+    assert wait.job.token.canceled?
+    refute wait.job.resolve({})
+
+    cancel = MirrorsSDK::Cancellation.new
+    wait = start
+    thread = Thread.new { sleep 0.01; cancel.cancel }
+    result = @host.await(wait, cancel: cancel)
+    thread.join
+    assert_equal "canceled", result.delivery
+    assert_equal "canceled", result.reason
+    assert wait.job.token.canceled?
+    assert_equal 0, @host.diagnostics[:pending_context]
+  end
+
+  def test_already_canceled_calls_do_not_schedule_work
+    activate
+    cancel = MirrorsSDK::Cancellation.new
+    cancel.cancel
+    assert_equal "canceled", @host.get(trace, cancel: cancel).reason
+    assert_empty @executor.jobs
+  end
+
+  def test_release_during_snapshot_preparation_cannot_resurrect_a_wait
+    activate
+    original = MirrorsSDK::Wire.method(:snapshot)
+    copying = lambda do |value, **options|
+      @host.release("execution")
+      original.call(value, **options)
+    end
+    MirrorsSDK::Wire.stub(:snapshot, copying) do
+      assert_equal "execution_closed", @host.get(trace).reason
+    end
+    assert_empty @executor.jobs
+    assert_equal 0, @host.diagnostics[:pending_context]
+  end
+
+  def test_host_thread_interruption_releases_retrieval_capacity
+    activate
+    wait = start
+    entered = Queue.new
+    thread = Thread.new { entered << true; @host.await(wait) }
+    entered.pop
+    eventually { thread.status == "sleep" }
+    thread.kill
+    thread.join
+    assert wait.job.token.canceled?
+    assert_equal 0, @host.diagnostics[:pending_context]
+  ensure
+    thread&.kill
+    thread&.join
+  end
+
+  def test_fail_open_for_invalid_options_evidence_and_transport
+    activate
+    [nil, 0, 1001, 1.5, true].each do |timeout|
+      assert_equal "invalid_options", @host.get(trace, timeout_ms: timeout).reason
+    end
+    assert_equal "invalid_evidence", @host.get({ "id" => "bad", "messages" => [Object.new] }).reason
+    wait = start
+    wait.job.reject(StandardError.new("scripted failure"))
+    assert_equal "transport", @host.await(wait).reason
+    invalid = MirrorsSDK::ContextHost.new(nil)
+    assert_equal "invalid_options", invalid.get(trace).reason
+  end
+end