wrangle 0.1.0 → 0.2.0

data/lib/wrangle/scope_registry.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "securerandom"
+require "time"
+
+require_relative "errors"
+
+module Wrangle
+  # Cross-session exclusive ownership for root surfaces.
+  class ScopeRegistry
+    Lease = Data.define(:path, :token, :mode)
+    Dispatch = Data.define(:path, :token)
+
+    def initialize(root: nil)
+      home = ENV["WRANGLE_HOME"] || File.join(Dir.home, ".wrangle")
+      @root = root || File.join(home, "scopes")
+      FileUtils.mkdir_p(@root, mode: 0o700)
+      File.chmod(0o700, @root)
+    end
+
+    def acquire(scope, mode: "exclusive")
+      valid = %w[exclusive cooperative].include?(mode)
+      raise ArgumentError, "Concurrency must be exclusive or cooperative" unless valid
+
+      ensure_no_unresolved_dispatch!(scope)
+      return Lease.new(path: nil, token: nil, mode:) if mode == "cooperative"
+
+      token = SecureRandom.hex(16)
+      path = path_for(scope)
+      payload = { "pid" => Process.pid, "token" => token, "scope_id" => scope.id,
+                  "root" => scope.root, "driver" => "macos" }
+      create(path, payload)
+      Lease.new(path:, token:, mode:)
+    rescue Errno::EEXIST
+      reclaim(path) ? retry : raise(ScopeBusy, "Root surface #{scope.root} is held by another exclusive session")
+    end
+
+    def release(lease)
+      return unless lease&.path && File.file?(lease.path)
+
+      stored = read(lease.path)
+      File.unlink(lease.path) if stored["token"] == lease.token
+    rescue Errno::ENOENT, JSON::ParserError
+      nil
+    end
+
+    # A durable marker crosses the only dangerous gap: process death after dispatch begins but before
+    # a receipt exists. It contains no labels or text, and is never reclaimed merely because its PID died.
+    def begin_dispatch(scope, proposal_id:, revision:, operation:)
+      ensure_no_unresolved_dispatch!(scope)
+      token = SecureRandom.hex(16)
+      path = dispatch_path_for(scope)
+      payload = { "pid" => Process.pid, "token" => token, "scope_id" => scope.id,
+                  "proposal_id" => proposal_id, "revision" => revision, "operation" => operation,
+                  "started_at" => Time.now.utc.iso8601(3) }
+      create(path, payload)
+      Dispatch.new(path:, token:)
+    rescue Errno::EEXIST
+      raise DeliveryUnknown, unresolved_dispatch_message
+    end
+
+    def finish_dispatch(dispatch)
+      return unless dispatch&.path
+
+      stat = File.lstat(dispatch.path)
+      raise DeliveryUnknown, unresolved_dispatch_message unless stat.file? && !stat.symlink?
+
+      stored = read(dispatch.path)
+      raise DeliveryUnknown, unresolved_dispatch_message unless stored["token"] == dispatch.token
+
+      File.unlink(dispatch.path)
+      sync_root
+    rescue Errno::ENOENT, JSON::ParserError
+      raise DeliveryUnknown, unresolved_dispatch_message
+    end
+
+    private
+
+    def path_for(scope) = File.join(@root, "#{scope_digest(scope)}.json")
+    def dispatch_path_for(scope) = File.join(@root, "#{scope_digest(scope)}.dispatch.json")
+
+    def scope_digest(scope)
+      identity = ["macos", scope.pid, scope.process_instance, scope.root].join("\0")
+      Digest::SHA256.hexdigest(identity)
+    end
+
+    def create(path, payload)
+      File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
+        file.write(JSON.generate(payload))
+        file.flush
+        file.fsync
+      end
+      sync_root
+    end
+
+    def ensure_no_unresolved_dispatch!(scope)
+      path = dispatch_path_for(scope)
+      return unless File.exist?(path) || File.symlink?(path)
+
+      stat = File.lstat(path)
+      raise DeliveryUnknown, unresolved_dispatch_message unless stat.file? && !stat.symlink?
+
+      read(path)
+      raise DeliveryUnknown, unresolved_dispatch_message
+    rescue Errno::ENOENT
+      nil
+    rescue JSON::ParserError
+      raise DeliveryUnknown, unresolved_dispatch_message
+    end
+
+    def unresolved_dispatch_message
+      "A previous action may have been delivered; inspect the application before starting another task"
+    end
+
+    def sync_root
+      File.open(@root, File::RDONLY, &:fsync)
+    end
+
+    def reclaim(path)
+      stat = File.lstat(path)
+      raise ScopeBusy, "Scope lease is not a regular owner-only file" unless stat.file? && !stat.symlink?
+
+      stored = read(path)
+      return false if process_alive?(stored["pid"])
+
+      File.unlink(path)
+      true
+    rescue Errno::ENOENT
+      true
+    rescue JSON::ParserError
+      raise ScopeBusy, "Scope lease is unreadable; remove #{path} after checking for a live session"
+    end
+
+    def read(path)
+      JSON.parse(File.read(path, 4096))
+    end
+
+    def process_alive?(pid)
+      return false unless pid.is_a?(Integer) && pid.positive?
+
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true
+    end
+  end
+end

data/lib/wrangle/session_server.rb

@@ -6,6 +6,7 @@ require "socket"
 
 require_relative "run_loop"
 require_relative "safari"
+require_relative "timing"
 
 module Wrangle
   # A Safari session that outlives a single command.
@@ -37,11 +38,12 @@ module Wrangle
 
     # `session` is injectable so the protocol, the diffing, and the refusal shapes can be tested
     # against a fake bridge instead of a browser.
-    def initialize(socket_path, options, session: nil, jev: nil)
+    def initialize(socket_path, options, session: nil, jev: nil, timing: Timing)
       @socket_path = socket_path
       @options = options
       @session = session
       @jev = jev
+      @timing = timing
       @page = nil
       @acted = 0
       @history = []
@@ -103,7 +105,7 @@ module Wrangle
     def watch(thinking)
       seen = @page && @page["fingerprint"]
       while thinking.alive?
-        sleep(STEADY_POLL)
+        pause(STEADY_POLL)
         break unless thinking.alive?
 
         looked = @session.observe
@@ -156,7 +158,7 @@ module Wrangle
       deadline = now + budget
       loop do
         before = @page["fingerprint"]
-        sleep(STEADY_POLL)
+        pause(STEADY_POLL)
         @page = @session.observe
         return @page if @page["fingerprint"] == before || now >= deadline
       end
@@ -181,10 +183,10 @@ module Wrangle
       if @options["window_id"]
         raise ArgumentError, "The MCP backend cannot attach to an existing window" if mcp?
 
-        Safari.attach(window_id: @options["window_id"], display: @options["display"])
+        Safari.attach(window_id: @options["window_id"], display: @options["display"], timing: @timing)
       else
         Safari.open(@options.fetch("url"),
-                    display: @options["display"], bounds: @options["bounds"],
+                    display: @options["display"], bounds: @options["bounds"], timing: @timing,
                     **(mcp? ? { bridge: McpBridge.new } : {}))
       end
     end
@@ -290,7 +292,7 @@ module Wrangle
       stable = 0
       moved = departed?(baseline, page)
       until now >= deadline || (stable >= STABLE_ROUNDS && (moved || now >= floor))
-        sleep SETTLE_POLL
+        pause(SETTLE_POLL)
         nxt = @session.observe
         stable = nxt["fingerprint"] == page["fingerprint"] ? stable + 1 : 0
         moved ||= departed?(baseline, nxt)
@@ -382,7 +384,7 @@ module Wrangle
       expect = request["expect"] && Regexp.new(request["expect"], Regexp::IGNORECASE)
       plan = Array(request["plan"]).filter_map { |goal| presence(goal) }
       plan = [request["goal"]] if plan.empty?
-      summarise(request, RunLoop.new(self, request, expect).run(plan), expect)
+      summarise(request, RunLoop.new(self, request, expect, timing: @timing).run(plan), expect)
     end
 
     def summarise(request, steps, expect)
@@ -399,7 +401,8 @@ module Wrangle
 
     def presence(value) = value.nil? || value.to_s.empty? ? nil : value.to_s
 
-    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    def now = @timing.now
+    def pause(seconds) = @timing.sleep(seconds)
 
     def shutdown
       begin
@@ -407,7 +410,10 @@ module Wrangle
       rescue Wrangle::Error
         nil # A poisoned session refuses to close its window. That refusal is the correct outcome.
       end
-      FileUtils.rm_f(@socket_path) if @socket_path
+      return unless @socket_path
+
+      FileUtils.rm_f(@socket_path)
+      FileUtils.rm_f("#{@socket_path}.pid")
     end
   end
 

data/lib/wrangle/tart_guest_driver.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "errors"
+require_relative "macos_driver"
+require_relative "macos_helper"
+
+module Wrangle
+  # Binds a Tart VM name to one guest boot generation. Every guest-helper request verifies the VM
+  # before and after transport, so a stop, reboot, replacement, or guest-agent reconnect loses scope
+  # instead of silently attaching to a new desktop.
+  class TartVM
+    NAME = /\A[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}\z/
+    DEFAULT_TART = ENV.fetch("WRANGLE_TART", "tart")
+    BOOT_COMMAND = %w[/usr/sbin/sysctl -n kern.boottime].freeze
+    BOOT_PATTERN = /\bsec = (\d+), usec = (\d+)\b/
+    TIMEOUT = 30
+
+    attr_reader :name, :instance
+
+    def initialize(name:, tart: DEFAULT_TART, runner_factory: nil, environment: ENV)
+      raise ArgumentError, "A valid Tart VM name is required" unless name.is_a?(String) && name.match?(NAME)
+      raise ArgumentError, "A Tart executable is required" if tart.to_s.empty? || tart.to_s.include?("\0")
+
+      @name = name
+      @tart = tart
+      @environment = filtered_environment(environment)
+      @runner_factory = runner_factory || method(:runner)
+      @instance = capture_instance
+    end
+
+    def around
+      verify!
+      result = yield
+      verify!
+      result
+    end
+
+    def verify!
+      actual = capture_instance
+      return true if actual == instance
+
+      raise DriverRefusal.new(
+        "scope_changed", "The scoped Tart guest restarted or was replaced",
+        delivery: "not_delivered", retry_disposition: "unsafe"
+      )
+    rescue DriverRefusal
+      raise
+    rescue DriverError
+      raise DriverRefusal.new(
+        "scope_changed", "The scoped Tart guest is no longer available",
+        delivery: "not_delivered", retry_disposition: "unsafe"
+      )
+    end
+
+    private
+
+    def capture_instance
+      selected = inventory.select { |record| record["Name"] == name }
+      unless selected.one? && selected.first["Running"] == true
+        raise DriverUnavailable, "The exact Tart guest is not running"
+      end
+
+      boot = run(@tart, "exec", name, *BOOT_COMMAND)
+      match = BOOT_PATTERN.match(boot)
+      raise DriverError, "The Tart guest returned no stable boot identity" unless match
+
+      "tart-guest-v1:#{name}:#{match[1]}:#{match[2]}"
+    end
+
+    def inventory
+      parsed = JSON.parse(run(@tart, "list", "--format", "json"))
+      valid = parsed.is_a?(Array) && parsed.all?(Hash)
+      raise DriverError, "Tart returned an invalid VM inventory" unless valid
+
+      parsed
+    rescue JSON::ParserError
+      raise DriverError, "Tart returned invalid VM inventory JSON"
+    end
+
+    def run(*command)
+      result = @runner_factory.call(command).call
+      raise DriverUnavailable, "Tart guest transport is unavailable" unless result.status.success?
+
+      result.stdout
+    end
+
+    def runner(command)
+      MacOSHelper::Runner.new(command:, environment: @environment, timeout: TIMEOUT)
+    end
+
+    def filtered_environment(source)
+      MacOSHelper::SAFE_ENV.each_with_object({}) { |key, kept| kept[key] = source[key] if source.key?(key) }
+    end
+  end
+
+  # Presents the normal MacOSHelper contract over Tart's argument-only guest-agent transport.
+  class TartGuestHelper
+    def initialize(vm_guard:, guest_app:, helper:)
+      @vm_guard = vm_guard
+      @guest_app = guest_app
+      @helper = helper
+    end
+
+    def ping = guarded { @helper.ping }
+    def displays = guarded { @helper.displays }
+
+    def windows(app:, titles: false)
+      validate_app!(app)
+      guarded do
+        windows = @helper.windows(app:, titles:)
+        unless windows.is_a?(Array) && windows.all?(Hash)
+          raise DriverError, "The guest helper returned an invalid window inventory"
+        end
+
+        windows.map do |window|
+          process = window["process_instance"]
+          process.is_a?(String) ? window.merge("process_instance" => scoped_process(process)) : window
+        end
+      end
+    end
+
+    def enable_accessibility(pid:, process_instance:)
+      guarded { @helper.enable_accessibility(pid:, process_instance: guest_process(process_instance)) }
+    end
+
+    def snapshot(pid:, process_instance:, window_id:, bounds:, root_target: nil, max_depth: 18)
+      guarded do
+        @helper.snapshot(
+          pid:, process_instance: guest_process(process_instance), window_id:, bounds:, root_target:, max_depth:
+        )
+      end
+    end
+
+    def execute(*)
+      raise DriverRefusal.new(
+        "read_only", "The Tart guest prototype does not dispatch actions",
+        delivery: "not_delivered", retry_disposition: "unsafe"
+      )
+    end
+
+    private
+
+    def guarded(&) = @vm_guard.around(&)
+
+    def validate_app!(app)
+      return if app.to_s.casecmp?(@guest_app)
+
+      raise ScopeLost, "The Tart guest driver cannot leave its explicit application scope"
+    end
+
+    def scoped_process(process_instance) = "#{@vm_guard.instance}/#{process_instance}"
+
+    def guest_process(process_instance)
+      prefix = "#{@vm_guard.instance}/"
+      unless process_instance.is_a?(String) && process_instance.start_with?(prefix)
+        raise ScopeLost, "The process does not belong to the scoped Tart guest"
+      end
+
+      process_instance.delete_prefix(prefix)
+    end
+  end
+
+  # Read-only exact-window driver for one explicitly named Tart VM and one explicitly named guest
+  # application. It deliberately exposes no mutation path and never falls back to the host Tart view.
+  class TartGuestDriver
+    DEFAULT_HELPER = ENV.fetch(
+      "WRANGLE_TART_GUEST_HELPER",
+      "/Users/admin/Applications/Wrangle Helper.app/Contents/MacOS/wrangle-macos-helper"
+    )
+
+    attr_reader :vm_name, :vm_instance, :guest_app
+
+    def initialize(vm_name:, guest_app:, tart: TartVM::DEFAULT_TART, guest_helper: DEFAULT_HELPER,
+                   guard: nil, helper: nil, driver: nil)
+      validate_helper!(guest_helper)
+      unless vm_name.is_a?(String) && vm_name.match?(TartVM::NAME)
+        raise ArgumentError, "A valid Tart VM name is required"
+      end
+      raise ArgumentError, "An explicit Tart guest application is required" if guest_app.to_s.strip.empty?
+
+      @guard = guard || TartVM.new(name: vm_name, tart:)
+      guest = helper || MacOSHelper.new(command: [tart, "exec", vm_name, guest_helper])
+      guarded = TartGuestHelper.new(vm_guard: @guard, guest_app:, helper: guest)
+      @driver = driver || MacOSDriver.new(helper: guarded, observation_driver: "tart_guest", read_only: true)
+      @vm_name = vm_name
+      @vm_instance = @guard.instance
+      @guest_app = guest_app
+    end
+
+    def doctor
+      result = @driver.doctor
+      capabilities = Hash(result["capabilities"]).merge("ax_dispatch" => "unavailable_read_only")
+      result.merge(
+        "environment" => "tart_guest", "vm" => vm_name, "guest_app" => guest_app,
+        "read_only" => true, "capabilities" => capabilities
+      )
+    end
+
+    def windows(app:, titles: false)
+      validate_app!(app)
+      @driver.windows(app:, titles:)
+    end
+
+    def displays = @driver.displays
+
+    def attach(window_id:, app:)
+      validate_app!(app)
+      @driver.attach(window_id:, app:).tap { |scope| validate_scope!(scope) }
+    end
+
+    def observe(scope, skeleton: true)
+      validate_scope!(scope)
+      @driver.observe(scope, skeleton:)
+    end
+
+    def drill(scope, ref:, snapshot_id:)
+      validate_scope!(scope)
+      @driver.drill(scope, ref:, snapshot_id:)
+    end
+
+    def execute(*)
+      {
+        "dispatch" => "not_delivered", "code" => "read_only",
+        "message" => "The Tart guest prototype does not dispatch actions", "retry_safe" => false
+      }
+    end
+
+    def close = @driver.close
+
+    private
+
+    def validate_scope!(scope)
+      return if scope.process_instance.to_s.start_with?("#{vm_instance}/")
+
+      raise ScopeLost, "The Tart guest scope is stale or belongs to another driver"
+    end
+
+    def validate_helper!(path)
+      valid = path.is_a?(String) && path.start_with?("/") && !path.include?("\0") && !path.include?("\n")
+      raise ArgumentError, "An absolute Tart guest helper path is required" unless valid
+    end
+
+    def validate_app!(app)
+      return if app.to_s.casecmp?(guest_app)
+
+      raise ScopeLost, "The Tart guest driver cannot leave its explicit application scope"
+    end
+  end
+end

data/lib/wrangle/timing.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Wrangle
+  # Real monotonic time and sleeping are defaults, not hard-coded dependencies. Tests and embedded
+  # callers can supply the same two-method interface to advance deadlines deterministically.
+  module Timing
+    module_function
+
+    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    def sleep(seconds) = Kernel.sleep(seconds)
+  end
+end

data/lib/wrangle/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wrangle
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/wrangle.rb

@@ -2,7 +2,24 @@
 
 require_relative "wrangle/version"
 require_relative "wrangle/errors"
+require_relative "wrangle/timing"
 require_relative "wrangle/observation"
+require_relative "wrangle/desktop_observation"
+require_relative "wrangle/desktop_policy"
+require_relative "wrangle/decision_provider"
+require_relative "wrangle/provider_qualification"
+require_relative "wrangle/provider_factory"
+require_relative "wrangle/desktop_decider"
+require_relative "wrangle/desktop_autonomy"
+require_relative "wrangle/desktop_session_autonomy"
+require_relative "wrangle/desktop_dispatch"
+require_relative "wrangle/desktop_effect"
+require_relative "wrangle/desktop_proposal"
+require_relative "wrangle/event_log"
+require_relative "wrangle/scope_registry"
+require_relative "wrangle/macos_helper"
+require_relative "wrangle/macos_driver"
+require_relative "wrangle/tart_guest_driver"
 require_relative "wrangle/jxa_bridge"
 require_relative "wrangle/mcp_bridge"
 require_relative "wrangle/safari"
@@ -10,8 +27,10 @@ require_relative "wrangle/jev"
 require_relative "wrangle/action_space"
 require_relative "wrangle/decider"
 require_relative "wrangle/session_server"
+require_relative "wrangle/desktop_session_server"
+require_relative "wrangle/desktop_task"
 
-# Hand one Safari window to a program, and no more than that.
+# Scoped computer use for macOS: one Safari window or one app window, and no more than that.
 #
 # Wrangle drives an ordinary Safari window through Apple Events. There is no automation session and
 # no extension, so the window stays a real one the user can see, keep, and take back at any moment.

data/skills/wrangle/SKILL.md

@@ -1,17 +1,50 @@
 ---
 name: wrangle
-description: Drive a real Safari window from the shell - open a page, see what it offers, click, type, and read results back. Use for looking things up on sites that need a real logged-in browser (flights, prices, dashboards, portals), filling a web form, or when the user says "use my browser", "check this site", or "/wrangle". Not for fetching static pages; use a normal HTTP fetch for those.
-compatibility: macOS with Safari, and `wrangle` on PATH. Requires Safari > Settings > Advanced > "Allow JavaScript from Apple Events", plus a one-time Apple Events permission prompt.
+description: Use a real, scoped macOS app or Safari window for requests such as "Check the #notifications channel in Boehs Slack", "use my browser", or "/wrangle". Prefer the computer tool when available; otherwise use the Safari CLI. Not for static public pages that normal HTTP can fetch.
+compatibility: macOS with Wrangle on PATH. Desktop use requires the repository Pi computer extension, Jev credentials (or an explicitly configured alternative provider), and Accessibility permission. Safari additionally requires JavaScript from Apple Events and its one-time permission prompt.
 ---
 
 # Wrangle
 
-Drive one real Safari window through a persistent session. Every command below is a shell command.
+Wrangle lets an agent work inside one real window without taking over the rest of the computer.
+
+## Natural desktop requests in Pi
+
+When the `computer` tool is available, call it **once** with the complete natural goal and application
+name. **Do not make the user learn Wrangle commands, window IDs, refs, proposal IDs, revisions,
+receipts, AX terminology, or provider configuration.** Wrangle owns window selection and the bounded
+read → typed decision → policy → action → verification loop.
+
+For example, when the user says:
+
+> Check the #notifications channel in Boehs Slack.
+
+call `computer` once with that goal and `app: "Slack"`, then summarize the returned visible evidence.
+Do not manually list, attach, observe, drill, find, preview, execute, or finish.
+
+- A plain imperative authorizes necessary reversible navigation, not Send, Delete, purchases, or
+  settings changes. Consequential actions stop before delivery. This alpha cannot resume the bound
+  proposal, so explain the limitation and do not call `computer` again in a loop.
+- Pass a literal only when it is exact non-secret text from the user's request. Never invent text.
+- Never use shell commands during or after a computer task—not for debugging, checking the date, or
+  bypassing a refusal. Never substitute a raw accessibility helper or another computer-use tool.
+- Wrangle stops at eight actions and three progressive drills. Failed or uncertain delivery is never
+  retried automatically.
+- Say what happened in the app: “I checked #notifications…” rather than describing decisions,
+  candidates, drivers, or receipts.
+- Wrangle releases control automatically on success or failure and **leaves the user's app window
+  open by design**. There is no separate finish call.
+- If delivery is uncertain, say plainly that the action may or may not have happened and do not retry.
+
+## Safari CLI
+
+Use the CLI when the `computer` tool is unavailable or the task specifically targets Safari. Every
+command below is a shell command.
 
 **Never write a Ruby script for this.** The CLI is the entire interface. If you catch yourself
 writing `require "wrangle"`, stop — use `wrangle observe` and `wrangle act` instead.
 
-## The loop
+### The loop
 
 ```bash
 wrangle open "https://example.com" --display 1 --settle 8   # start; prints the first observation

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wrangle
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Eric Boehs
@@ -10,10 +10,10 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
-  Wrangle drives an ordinary Safari window through Apple Events: no automation session, no
-  extension, no native helper. The window stays a real one you can see, keep, and take back.
-  Scope is the safety boundary - one window id, one tab position, one expected URL, one document
-  epoch - and losing any of them ends the session rather than starting a search for a substitute.
+  Wrangle gives an agent one exact application window or Safari tab and no more than that. Its
+  native macOS driver runs a bounded typed-decision loop with policy, fresh-target validation,
+  at-most-once dispatch, and independent effect verification. Safari uses Apple Events for fast
+  DOM-grounded actions. Losing scope ends the task rather than searching for a substitute.
 email:
 - ericboehs@gmail.com
 executables:
@@ -28,17 +28,39 @@ files:
 - lib/wrangle.rb
 - lib/wrangle/action_space.rb
 - lib/wrangle/decider.rb
+- lib/wrangle/decision_provider.rb
+- lib/wrangle/desktop_autonomy.rb
+- lib/wrangle/desktop_decider.rb
+- lib/wrangle/desktop_dispatch.rb
+- lib/wrangle/desktop_effect.rb
+- lib/wrangle/desktop_observation.rb
+- lib/wrangle/desktop_policy.rb
+- lib/wrangle/desktop_progressive_observation.rb
+- lib/wrangle/desktop_proposal.rb
+- lib/wrangle/desktop_session_autonomy.rb
+- lib/wrangle/desktop_session_server.rb
+- lib/wrangle/desktop_task.rb
 - lib/wrangle/errors.rb
+- lib/wrangle/event_log.rb
 - lib/wrangle/jev.rb
 - lib/wrangle/js/bridge.js
 - lib/wrangle/js/page.js
 - lib/wrangle/js/snapshot.js
 - lib/wrangle/jxa_bridge.rb
+- lib/wrangle/macos/helper.swift
+- lib/wrangle/macos_driver.rb
+- lib/wrangle/macos_helper.rb
 - lib/wrangle/mcp_bridge.rb
 - lib/wrangle/observation.rb
+- lib/wrangle/provider_conformance.jsonl
+- lib/wrangle/provider_factory.rb
+- lib/wrangle/provider_qualification.rb
 - lib/wrangle/run_loop.rb
 - lib/wrangle/safari.rb
+- lib/wrangle/scope_registry.rb
 - lib/wrangle/session_server.rb
+- lib/wrangle/tart_guest_driver.rb
+- lib/wrangle/timing.rb
 - lib/wrangle/version.rb
 - skills/wrangle/SKILL.md
 homepage: https://github.com/ericboehs/wrangle
@@ -63,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
-summary: Hand one Safari window to a program, and no more than that.
+summary: Scoped, policy-gated computer use for real macOS and Safari windows.
 test_files: []