agent-cli-runtime 0.2.0 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38323f74e355a6a9da1dfb45ccee48c253ffbd0c9693a16cd62910ced381c7cb
-  data.tar.gz: 2e38766e9b737df1e5360ac8013849cf2108dab3f8b937f24ec393c001aba669
+  metadata.gz: e0202bb311856ad96fcd486517d11cfc7175db0102a188920c4d851bf338b7d6
+  data.tar.gz: 2e72a23b5e7a021fc439a9ce8ef34bf166c0af0141de491a27686d6f3ba3f139
 SHA512:
-  metadata.gz: 95e1213e6586ea162e2a12294b350d4ea5190c8f09239e276fe4de17ceb1a7787c0c4979e3e71c6acb0f8e318facea099820a221130b123549d8a123c13e62b7
-  data.tar.gz: 1cca33e3af240a7abf5b8627d69256ee43647557fc2aeeab4f74692c7ba08ff74a0b0a5cdef202796f4559cc04d0498138762003fd14845c61029bd0b7603231
+  metadata.gz: b3736f38aa29d809028b1e99c9df1dd17ddb4a210382e89f752def380e84cf22e3f144da2d10ee6c86c2dab8496865a35347196277367a0734b9c39991c33f0e
+  data.tar.gz: 5adacccc362958a8cc9a2eeab22b9100041101de4795d7f31ddaa563406ec031f6b3662e84eca058b144ab86ee41d1505c42baa267c1eae436cda4566680b100

data/CHANGELOG.md

@@ -2,23 +2,90 @@
 
 ## Unreleased
 
+## 0.2.4 - 2026-08-25
+
+- Expose the OpenCode permission compiler independently from the prepared
+  overlay so callers can supply the same deny-first rules through native
+  per-process configuration without duplicating policy generation.
+
+- Carry the already-resolved OpenCode executable on `ProbeRequest` (`executable:`)
+  instead of re-encoding it as the `AGENT_CLI_RUNTIME_OPENCODE_BIN` environment
+  override. The route-aware probe now resolves the executable once — honoring a
+  caller-supplied value first — and threads that single value through the
+  installation check, version check, every local inspection command, and the
+  reported result executable. `Profile#binary_installed?`,
+  `Profile#check_version!`, and `Profile#capture_local` accept an optional
+  `executable:` override; existing environment-based resolution is unchanged
+  when no explicit value is carried.
+
+## 0.2.3 - 2026-08-21
+
+- Classify extracted provider failures once at the runtime boundary as
+  `provider_limit`, `rate_limited`, `model_output_limit`, or `provider_error`.
+  HTTP 402/429 payloads are authoritative even when their provider-specific
+  wording does not match an orchestrator's legacy quota phrases.
+
+## 0.2.2 - 2026-08-18
+
+- Deliver built-in Pi prompts through its native non-TTY stdin reader instead
+  of one positional argv element. This prevents implementation-sized prompts
+  from failing at process spawn with the operating system's per-argument
+  `E2BIG` limit; Codex retains its separate stdin-plus-`-` transport.
+- Treat Pi's `stopReason: "length"` as a typed `model_output_limit` failure.
+  Pi exits zero after this provider stop even when the model exhausted its
+  output allowance before writing the requested artifact; callers can now
+  distinguish that incomplete turn from an agent that silently produced
+  0 bytes and tell operators to raise `maxTokens` or lower reasoning effort.
+- Declare Grok's filesystem sandbox flags, so a caller asking for confined
+  execution gets it instead of being told Grok cannot confine. `--sandbox
+  workspace` limits writes to the working directory and `--sandbox read-only`
+  forbids them, both built-in profiles that custom ones extend from
+  `~/.grok/sandbox.toml`; `--always-approve` suppresses the approval prompt a
+  headless run can never answer, leaving the sandbox — not the prompt — as the
+  boundary. Only the Grok profile changes.
+
+## 0.2.1 - 2026-08-17
+
+- Add per-profile provider-error extraction so a refusal a CLI reports on its
+  event stream is distinguishable from an agent that genuinely produced
+  nothing. `extract_provider_error` returns the provider, the HTTP status when
+  the provider supplied one, and the redacted provider text.
+- Add the `pi` extractor for turns that keep the envelope type and carry the
+  refusal in `stopReason`/`errorMessage`, which no event-type match observes.
+  Such turns previously reached the caller as a clean run with empty content
+  while the process exited zero.
+- Default every other profile to the previously assumed shapes — dedicated
+  `error`, `turn.failed`, and `rate_limit_event` events plus failed `result`
+  events — so no existing profile changes behaviour.
+- Read usage from the assistant message and accept the bare
+  `input`/`output`/`cacheRead`/`cacheWrite` spellings, so a provider reporting
+  usage there is metered instead of silently recording nothing. The bare
+  spellings are matched last, leaving a provider that reports explicit
+  `*_tokens` keys with its existing reading.
+
 ## 0.2.0 - 2026-08-15
 
-- Add OpenCode `1.18.16+` as a fifth immutable built-in profile with exact
-  `provider/model` routing and faithful model-variant validation.
-- Add route-aware offline probing for the required run/export flags, selected
-  authentication source, cached model inventory, and exact requested route.
-- Add invocation-owned OpenCode config/data/cache/state overlays with
-  deny-first `read-only` and `workspace-write` policies, explicit credential
-  forwarding, owner-private resources, and idempotent cleanup.
-- Add strict run/export correlation and typed outcomes for completion,
-  authentication/configuration/CLI failure, malformed output, cancellation,
-  and timeout while preserving requested versus actual route identity.
-- Preserve unavailable separately from numeric zero for input, output,
-  cache-read, cache-write, reasoning, and cost evidence.
-- Keep process spawning, streaming, timeout/cancellation supervision,
-  process-tree cleanup, retries, and post-run inspection execution with the
-  caller; the component returns commands and normalizes captured evidence.
+- Add first-class OpenCode `1.18.16+` support alongside the built-in Claude
+  Code, Codex CLI, Pi, and Grok CLI profiles. OpenCode uses the shared request
+  and facade, then adds provider-specific preparation, route probing, and
+  strict result normalization.
+- Route every OpenCode run to an exact `provider/model` and validate model
+  variants, preserving the route the application requested and the route the
+  captured result reports.
+- Prepare owner-private OpenCode config, data, cache, and state overlays for
+  each invocation, with scoped `read-only` and `workspace-write` policies,
+  deliberate credential forwarding, and idempotent cleanup.
+- Check run/export capabilities, selected authentication source, cached model
+  inventory, and the exact requested route locally before an application
+  starts work.
+- Correlate run and sanitized-export evidence into typed outcomes for
+  completion, authentication, configuration, CLI failure, malformed output,
+  cancellation, and timeout.
+- Report input, output, cache-read, cache-write, reasoning, and cost evidence
+  while preserving the difference between unavailable data and numeric zero.
+- Return prepared commands and normalized evidence through lifecycle-safe
+  values that fit an application's existing streaming, timeout, cancellation,
+  retry, and process-supervision stack.
 
 ## 0.1.1 - 2026-08-11
 

data/README.md

@@ -1,12 +1,31 @@
 # Agent CLI Runtime
 
-`agent-cli-runtime` is a small Ruby library for tools that integrate with
-locally installed headless agent CLIs. It ships immutable profiles for Claude
-Code, Codex CLI, Pi, Grok CLI, and OpenCode and compiles provider-neutral
-requests into argv/stdin. It also reports typed capability evidence, extracts
-usage from provider JSON events, and exposes an honest local diagnostic
-command. OpenCode adds an invocation-owned overlay and strict captured-result
-normalizer while leaving process supervision with the caller.
+Agent CLI Runtime gives Ruby applications one stable integration layer for
+Claude Code, Codex CLI, Pi, Grok CLI, and OpenCode. It builds provider-specific
+commands from a shared request model, checks local versions and named
+capabilities, and normalizes usage and results afterward. Centralized profiles,
+environment rules, and parsers make agent providers easier to add, switch, and
+upgrade.
+
+Version 0.2.0 adds first-class OpenCode support with exact `provider/model`
+routing, isolated per-invocation configuration, scoped permission policies,
+offline readiness checks, and typed outcome normalization. See the
+[changelog](CHANGELOG.md) for the complete release notes.
+
+## Why use it?
+
+Agent CLIs disagree on flags, prompt transport, configuration locations,
+permission controls, usage events, and result formats. Agent CLI Runtime keeps
+those differences in versioned profiles so application code can use one
+request and result vocabulary.
+
+- Add or switch agent CLIs without spreading provider conditionals throughout
+  the application.
+- Validate installed versions, capabilities, and exact routes before starting
+  work.
+- Preserve typed usage and outcome evidence across provider-specific output
+  formats.
+- Add custom profiles through the same immutable compatibility contract.
 
 ## Install
 
@@ -41,6 +60,11 @@ Compilation does not execute the returned command. Unsupported requested
 controls raise `AgentCliRuntime::UnsupportedCapability` with typed evidence
 instead of silently widening the request.
 
+Prompt transport is profile-owned. `:stdin` writes the prompt to stdin and
+adds the CLI's conventional `-` argv marker; `:piped_stdin` writes the prompt
+to stdin without a marker for CLIs such as Pi that consume a non-TTY stream
+directly. Built-in Pi therefore keeps arbitrarily large prompts out of argv.
+
 `permission_mode: nil` selects the profile's default non-interactive permission
 flags, which may include a provider's bypass flag. Pass `"read-only"` or
 `"workspace-write"` explicitly when the integration requires that constraint.
@@ -58,12 +82,14 @@ represent.
 - `extract_usage(profile, event)` normalizes provider usage when present and
   returns `nil` when usage is absent or malformed.
 - `observe(profile, result)` normalizes bounded, redacted result metadata.
-- `prepare!(open_code_preparation)` creates and probes an isolated OpenCode
-  overlay and returns a `PreparedInvocation`; it does not spawn OpenCode.
+- `prepare!(open_code_preparation)` returns a `PreparedInvocation` containing
+  an isolated OpenCode overlay, argv, and child environment.
+- `OpenCode::Permissions.compile(...)` returns the same deny-first permission
+  document independently for callers that retain native OpenCode state.
 - `parse_run(profile, stdout:)` parses a successful OpenCode JSONL capture
   into the session and terminal-message identity required for inspection.
-- `prepare_inspection(prepared, parsed_run)` compiles the non-model sanitized
-  session-export command without executing it.
+- `prepare_inspection(prepared, parsed_run)` returns the non-model sanitized
+  session-export invocation.
 - `normalize(profile, captured, requested_route:)` returns one typed OpenCode
   outcome from caller-captured run, termination, and inspection evidence.
 
@@ -125,6 +151,11 @@ read-only configuration source. Configuration may define providers and an
 exact default model, but it must not contain credential values. Name the
 credential environment variables the caller is allowed to forward instead.
 
+Callers that deliberately retain native OpenCode config and login can use
+`OpenCode::Permissions.compile` directly and pass the JSON document through
+OpenCode's per-process permission input. The prepared-overlay API below
+remains the closed, isolated option.
+
 ```ruby
 require "agent_cli_runtime"
 require "tmpdir"
@@ -150,7 +181,8 @@ preparation = AgentCliRuntime::OpenCodePreparationRequest.new(
   },
   credential_environment_keys: ["ANTHROPIC_API_KEY"],
   additional_read_roots: [Dir.pwd],
-  additional_write_roots: [Dir.pwd]
+  additional_write_roots: [Dir.pwd],
+  bash_patterns: ["git*", "bundle*", "bin/*"]
 )
 
 prepared = AgentCliRuntime.prepare!(preparation)
@@ -198,8 +230,10 @@ to call twice. Call it from the process owner's `ensure` path after every
 pre-spawn and post-spawn outcome.
 
 `read-only` denies edits, shell, unsafe tools, and external writes.
-`workspace-write` permits edits only under the declared write roots and still
-denies unrestricted shell. A `nil` permission mode is rejected unless the
+`workspace-write` permits edits only under the declared write roots. Shell is
+denied unless the caller supplies explicit OpenCode `bash_patterns`; those
+patterns are application permissions, not an OS sandbox. A `nil` permission
+mode is rejected unless the
 consumer supplies an explicit typed `OpenCodePermissionPolicy`; the ordinary
 preparation API never silently falls back to a bypass. Plugin sources are
 explicit, and `--pure` remains enabled when no plugin was selected.
@@ -218,10 +252,12 @@ model request:
 bundle exec ruby -Itest test/opencode_offline_smoke_test.rb
 ```
 
-If an installation command is itself a package-manager shim, set
-`AGENT_CLI_RUNTIME_OPENCODE_OFFLINE_BIN` to the already-installed native
-OpenCode executable so the smoke cannot trigger shim installation or refresh
-behavior.
+Auto-discovery considers every matching executable in `PATH` and prefers an
+already-installed native executable over an earlier package-manager launcher,
+including script and multicall-binary shims, so the
+smoke cannot trigger package-manager installation or refresh behavior. If only
+a shim is discoverable, set `AGENT_CLI_RUNTIME_OPENCODE_OFFLINE_BIN` to the
+native OpenCode executable explicitly.
 
 The authenticated atomic-edit smoke is separately gated and refuses to run
 without an explicit route, config path, credential variable name, opt-in, and

data/agent-cli-runtime.gemspec

@@ -5,13 +5,14 @@ Gem::Specification.new do |spec|
   spec.version = AgentCliRuntime::VERSION
   spec.authors = [ "Ivan Kuznetsov" ]
   spec.email = [ "ivan@ikuznetsov.com" ]
-  spec.summary = "Provider-neutral contracts for installed agent CLIs"
+  spec.summary =
+    "One Ruby API for Claude Code, Codex CLI, Pi, Grok CLI, and OpenCode"
   spec.description = <<~DESC
-    Agent CLI Runtime provides immutable profiles, invocation compilation,
-    local prerequisite probes, capability evidence, usage extraction, and
-    result normalization for Claude Code, Codex CLI, Pi, Grok CLI, and
-    OpenCode. It does not spawn agents or claim live provider health, quota,
-    or credential validity.
+    Agent CLI Runtime gives Ruby applications one stable integration layer for
+    local coding-agent CLIs. It builds provider-specific commands from a shared
+    request model, checks local versions and named capabilities, and normalizes
+    usage and results afterward. Centralized profiles, environment rules, and
+    parsers make agent providers easier to add, switch, and upgrade.
   DESC
   spec.homepage = "https://github.com/ivankuznetsov/agent-cli-runtime"
   spec.license = "MIT"

data/lib/agent_cli_runtime/error_extractors.rb

@@ -0,0 +1,95 @@
+module AgentCliRuntime
+  # Provider-side failures that a CLI reports on its event stream while still
+  # exiting zero. Each profile owns the shape its own CLI emits. Extractors
+  # return either the raw provider text, an ExtractedFailure, or nil when the
+  # event carries no failure. Runtime.extract_provider_error normalizes and
+  # redacts the result.
+  module ErrorExtractors
+    module_function
+
+    # CLIs that name the failure with a dedicated event type. This is the same
+    # set Hive scanned for inline before provider shape moved behind the
+    # profile, so wiring a profile to DEFAULT preserves its behaviour.
+    DEFAULT = lambda do |event|
+      next nil unless event.is_a?(Hash)
+
+      case event["type"]
+      when "error", "turn.failed", "rate_limit_event"
+        ErrorExtractors.message_from(event)
+      when "result"
+        if event["is_error"] == true || event["subtype"].to_s.start_with?("error")
+          ErrorExtractors.message_from(event)
+        end
+      end
+    end
+
+    # Claude's subscription wall is a dedicated structured event with no
+    # human-readable message. The generic extractor therefore returned nil,
+    # leaving callers to flatten a rejected five-hour/seven-day window into a
+    # generic exit-code failure. Accept only the exact rejected account-window
+    # shapes observed from Claude Code and synthesize bounded provider text for
+    # the normal typed limit path. Other Claude errors retain DEFAULT behavior.
+    CLAUDE_ACCOUNT_LIMIT_TYPES = %w[five_hour seven_day].freeze
+    CLAUDE = lambda do |event|
+      if event.is_a?(Hash) && event["type"] == "rate_limit_event"
+        info = event["rate_limit_info"]
+        if info.is_a?(Hash) && info["status"] == "rejected"
+          limit_type = info["rateLimitType"].to_s
+          if CLAUDE_ACCOUNT_LIMIT_TYPES.include?(limit_type)
+            next ExtractedFailure.new(
+              kind: :provider_limit,
+              message: "Claude account quota reached (#{limit_type})"
+            )
+          end
+        end
+      end
+
+      DEFAULT.call(event)
+    end
+
+    # pi keeps the envelope type ("message_start"/"message_end") and moves the
+    # terminal state into stopReason. Provider refusals use
+    # stopReason=error/errorMessage. A model that consumes its entire output
+    # allowance uses stopReason=length and can exit zero without executing the
+    # final write tool. Matching on type alone sees neither failure.
+    PI = lambda do |event|
+      next nil unless event.is_a?(Hash)
+
+      message = event["message"].is_a?(Hash) ? event["message"] : event
+      case message["stopReason"].to_s
+      when "error"
+        ErrorExtractors.message_from(message) || ErrorExtractors.message_from(event)
+      when "length"
+        ExtractedFailure.new(
+          kind: :model_output_limit,
+          message: "model response reached its maximum output tokens"
+        )
+      end
+    end
+
+    # OpenCode keeps provider failures under error.data.message rather than
+    # the top-level/message and error.message shapes used by the default
+    # extractor. Read only the dedicated error event so ordinary model text
+    # cannot forge a provider-limit signal.
+    OPENCODE = lambda do |event|
+      next nil unless event.is_a?(Hash) && event["type"] == "error"
+
+      data = event.dig("error", "data")
+      message = data["message"] if data.is_a?(Hash)
+      message if message.is_a?(String) && !message.strip.empty?
+    end
+
+    def message_from(event)
+      return nil unless event.is_a?(Hash)
+
+      candidates = [
+        event["errorMessage"],
+        event["message"],
+        event.dig("error", "message"),
+        event["error"]
+      ]
+      text = candidates.find { |value| value.is_a?(String) && !value.strip.empty? }
+      text&.strip
+    end
+  end
+end

data/lib/agent_cli_runtime/opencode/overlay.rb

@@ -66,12 +66,26 @@ module AgentCliRuntime
           preparation.credential_environment_keys
         )
         plugins = selected_plugins(source_config, preparation.plugins)
-        permission = permission_rules(preparation, roots, plugins: plugins)
 
         root = create_root!(preparation.invocation_root)
         cleanup = Cleanup.new(root)
         begin
           paths = create_directories(root)
+          permission = Permissions.compile(
+            permission_mode: preparation.request.permission_mode,
+            permission_policy: preparation.permission_policy,
+            working_directory: roots.fetch(:working),
+            additional_read_roots: roots.fetch(:read),
+            additional_write_roots: roots.fetch(:write),
+            edit_patterns: preparation.edit_patterns,
+            bash_patterns: preparation.bash_patterns,
+            plugins: plugins,
+            runtime_write_roots: [ paths.fetch(:temporary) ]
+          )
+          unless permission
+            raise ConfigurationError,
+                  "OpenCode requires an explicit OpenCode permission policy when permission_mode is nil"
+          end
           pure = preparation.pure && plugins.empty?
           config = generated_configuration(
             source_config, plugins, requested_route, permission
@@ -91,9 +105,6 @@ module AgentCliRuntime
           )
           executable =
             preparation.request.executable || profile.bin(env: env)
-          probe_env = env.to_h.merge(
-            "AGENT_CLI_RUNTIME_OPENCODE_BIN" => executable
-          )
           probe_request = ProbeRequest.new(
             profile: profile,
             route: requested_route,
@@ -103,9 +114,12 @@ module AgentCliRuntime
             credential_file_staged:
               staged_credential && credential_file_supports_provider?(
                 staged_credential.last, requested_route.provider
-              )
+              ),
+            configured_variants:
+              configured_variants(source_config, requested_route),
+            executable: executable
           )
-          probe_result = OpenCode::Probe.call!(probe_request, env: probe_env)
+          probe_result = OpenCode::Probe.call!(probe_request, env: env)
           invocation = compile_invocation(
             preparation, profile, requested_route, roots,
             executable:, pure: pure,
@@ -175,6 +189,21 @@ module AgentCliRuntime
       end
       private_class_method :validate_provider!
 
+      # A selected OpenCode configuration may declare a custom model that is
+      # newer than the CLI's bundled provider catalog. With model fetching
+      # disabled for hermetic launches, that declaration is durable route
+      # evidence; the large `models --verbose` inventory is complementary,
+      # not its replacement.
+      def configured_variants(config, route)
+        models = config.dig("provider", route.provider, "models")
+        return nil unless models.is_a?(Hash) && models.key?(route.model)
+
+        definition = models.fetch(route.model)
+        variants = definition.is_a?(Hash) ? definition["variants"] : nil
+        variants.is_a?(Hash) ? variants.keys.sort.freeze : [].freeze
+      end
+      private_class_method :configured_variants
+
       def validate_nonsecret!(value, key = nil)
         case value
         when Hash
@@ -244,120 +273,6 @@ module AgentCliRuntime
       end
       private_class_method :resolve_roots
 
-      def permission_rules(preparation, roots, plugins: preparation.plugins)
-        mode = preparation.request.permission_mode
-        if mode.nil?
-          policy = preparation.permission_policy
-          unless policy
-            raise ConfigurationError,
-                  "OpenCode requires an explicit OpenCode permission policy when permission_mode is nil"
-          end
-          return deep_copy(policy.rules)
-        end
-
-        unless %w[read-only workspace-write].include?(mode)
-          raise ConfigurationError,
-                "unsupported OpenCode permission mode"
-        end
-
-        external = { "*" => "deny" }
-        (roots.fetch(:read) + roots.fetch(:write)).uniq.each do |root|
-          external[root] = "allow"
-          external["#{root}/**"] = "allow"
-        end
-        common = {
-          "*" => "deny",
-          "read" => {
-            "*" => "allow",
-            "*.env" => "deny",
-            "*.env.*" => "deny",
-            "*.env.example" => "allow"
-          },
-          "glob" => "allow",
-          "grep" => "allow",
-          "list" => "allow",
-          "lsp" => "allow",
-          "skill" => plugins.empty? ? "deny" : "allow",
-          "external_directory" => external
-        }
-        if mode == "read-only"
-          return common.merge(
-            "edit" => "deny", "bash" => "deny", "task" => "deny",
-            "webfetch" => "deny", "websearch" => "deny",
-            "question" => "deny"
-          )
-        end
-
-        # OpenCode applies the last matching permission rule. Start from a
-        # denial and append only the invocation's declared write roots. The
-        # working directory is an implicit write root for workspace-write;
-        # additional read roots remain explicitly denied unless the caller
-        # also declared them writable.
-        writable_roots = [ roots.fetch(:working), *roots.fetch(:write) ].uniq
-        edit = { "*" => "deny" }
-        allows = if preparation.edit_patterns.empty?
-          writable_roots.flat_map do |root|
-            edit_patterns(root, working: roots.fetch(:working))
-          end
-        else
-          normalize_declared_edit_patterns(
-            preparation.edit_patterns, writable_roots,
-            working: roots.fetch(:working)
-          )
-        end
-        allows.each do |pattern|
-            edit[pattern] = "allow"
-        end
-        (roots.fetch(:read) - roots.fetch(:write)).each do |root|
-          edit_patterns(root, working: roots.fetch(:working)).each do |pattern|
-            edit[pattern] = "deny"
-          end
-        end
-        common.merge(
-          "edit" => edit, "bash" => "deny", "task" => "deny",
-          "webfetch" => "deny", "websearch" => "deny",
-          "question" => "deny"
-        )
-      end
-      private_class_method :permission_rules
-
-      def edit_patterns(root, working:)
-        if root == working
-          [ "**" ]
-        elsif root.start_with?(working + File::SEPARATOR)
-          relative = root.delete_prefix(working + File::SEPARATOR)
-          [ relative, "#{relative}/**" ]
-        else
-          [ root, "#{root}/**" ]
-        end
-      end
-      private_class_method :edit_patterns
-
-      def normalize_declared_edit_patterns(patterns, writable_roots, working:)
-        patterns.map do |value|
-          pattern = value.sub(%r{\A//}, "/")
-          unless File.absolute_path?(pattern) && !pattern.include?("\0")
-            raise ConfigurationError,
-                  "OpenCode edit patterns must be absolute path patterns"
-          end
-          literal_prefix = pattern.split(/[*?]/, 2).first.sub(%r{/+\z}, "")
-          unless writable_roots.any? do |root|
-            literal_prefix == root || literal_prefix.start_with?(root + File::SEPARATOR)
-          end
-            raise ConfigurationError,
-                  "OpenCode edit pattern is outside the declared write roots"
-          end
-          if pattern == working
-            "**"
-          elsif pattern.start_with?(working + File::SEPARATOR)
-            pattern.delete_prefix(working + File::SEPARATOR)
-          else
-            pattern
-          end
-        end.uniq.freeze
-      end
-      private_class_method :normalize_declared_edit_patterns
-
       def create_root!(value)
         path = File.expand_path(value)
         unless File.absolute_path?(value.to_s)