ace-llm-providers-cli 0.27.2 → 0.31.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f5ca95d3a35ffa8444237fc73e23009fbf00b11c2a7b08e96cd97471d579096
-  data.tar.gz: 24a6c886c4c267b7cd8181453570fc6f14b18bea8a8bd6483a3dd02869a20796
+  metadata.gz: 0ae114fa300c121e8b2d358ae3ef2ad16e3d53bf981b11e2c2be59eb2c5c29d6
+  data.tar.gz: e3b9479472b714507dfb0bbb82dd10b19b3e403bfcd9fe0a107fd3194975e65a
 SHA512:
-  metadata.gz: b564fe237a162b9eec870def80c0da8239f4137d5c8485ad28d4bfc6cb4e36eb70d6cd6940f63a9ffe5c5741109558e17c46c75106fe82174cad8d7439baea86
-  data.tar.gz: 1fa88f5b98701c38caa0e7ddc8e4450d4fd9f7166a7647169185989c0a5b2e8759e0423d6780fd370d3d1f77bd5763dabd6ecce87fc201ed0cf19bb8eb718684
+  metadata.gz: 68cf79d47bbdf06e62e8e8d79a72ed5a607d249ff57cbf767696f8580066b5188ac1f3920a3bf8f3b998de290067f75d58379670472cd5b57c61d613499e8de6
+  data.tar.gz: f3d14332bb1d44bdf0fc8906afd6576e7349bf2ea12ac1ebeedc32d535156bce4ff948bd1323e5ee0691b0d88f365d8a4b1ec9a0b8460849867c899a8af8cc4d

data/.ace-defaults/llm/providers/codex.yml

@@ -2,16 +2,21 @@ name: codex
 class: Ace::LLM::Providers::CLI::CodexClient
 gem: ace-llm-providers-cli
 models:
-  - gpt-5
-  - gpt-5-mini
+  - gpt-5.3-codex
+  - gpt-5.3-codex-spark
+  - gpt-5.4
+  - gpt-5.4-mini
 aliases:
   global:
-    codex-gpt5: codex:gpt-5
-    codex-mini: codex:gpt-5-mini
+    codex-gpt5: codex:gpt-5.4
+    codex-mini: codex:gpt-5.4-mini
   model:
-    5: gpt-5
-    mini: gpt-5-mini
-    m: gpt-5-mini
+    5: gpt-5.4
+    gpt: gpt-5.4
+    codex: gpt-5.3-codex
+    spark: gpt-5.3-codex-spark
+    mini: gpt-5.4-mini
+    m: gpt-5.4-mini
 capabilities:
   - text_generation
   - code_generation

data/.ace-defaults/llm/providers/gemini.yml

@@ -19,7 +19,9 @@ aliases:
     2.0-flash: gemini-2.0-flash
     1.5-pro: gemini-1.5-pro-latest
     flash: gemini-2.5-flash
+    flash-latest: gemini-2.5-flash
     pro: gemini-2.5-pro
+    pro-latest: gemini-2.5-pro
 capabilities:
   - text_generation
   - code_generation

data/CHANGELOG.md

@@ -7,6 +7,100 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.31.2] - 2026-04-16
+
+### Fixed
+- Updated shipped Codex defaults from the rejected `gpt-5-mini` alias path to the current `gpt-5.4` / `gpt-5.4-mini` catalog and aligned the CLI client metadata with those model IDs.
+- Added shipped `flash-latest` and `pro-latest` Gemini aliases backed by declared default models so fresh-provider fallback chains no longer target missing Gemini aliases.
+
+## [0.31.1] - 2026-04-16
+
+### Fixed
+- Updated `TS-LLMCLI-001` sandbox setup to source `mise.toml` from `${ACE_E2E_SOURCE_ROOT:-$PROJECT_ROOT_PATH}`, keeping CLI smoke runs compatible with read-only source-root mounts.
+
+## [0.31.0] - 2026-04-15
+
+### Changed
+- Reworked `TS-LLMCLI-001` to public-surface goal-style guidance by removing hidden `which` interception,
+  introducing deterministic sandbox-safe runtime/stub setup, and clarifying provider-discovery harness rules.
+
+### Technical
+- Added E2E verification lifecycle metadata guidance (`Last verified`, `Verified by`, refresh trigger) in
+  scenario decision/verifier docs.
+- Updated package README testing guidance for deterministic provider-discovery harness behavior.
+
+## [0.30.0] - 2026-04-15
+
+### Fixed
+- Added a Codex tmux startup overlay that trusts the exact working directory through a temporary per-workspace Codex home, preventing fresh tmux sandboxes from blocking on the trust prompt before agent work begins.
+
+### Changed
+- Switched tmux-facing Codex launches to reuse the shared `ace-llm --interactive` entrypoint, so provider skill translation, alias resolution, preset handling, and startup policy all flow through one path.
+
+## [0.29.0] - 2026-04-15
+
+### Added
+- Added native interactive invocation builders for Codex, Claude Code, and pi so CLI providers can be launched without their one-shot print/exec flags while still receiving translated ACE skill handoffs.
+
+### Technical
+- Added shared CLI-arg conflict guards plus Claude slash-command formatting support for the new interactive launch path.
+
+## [0.28.6] - 2026-04-13
+
+### Fixed
+- Cleared `CLAUDECODE` during Claude help capability probes so nested Claude Code sessions no longer cache false negatives for `--max-tokens` support.
+
+### Technical
+- Added regression coverage for the help-probe environment handling.
+
+## [0.28.5] - 2026-04-13
+
+### Fixed
+- Avoided eager Claude CLI capability probes during normal command construction so non-`max-tokens` requests no longer shell out to `claude --help`.
+
+### Technical
+- Restored deterministic command-builder coverage by guarding common-path unit tests from unexpected capability probing.
+
+## [0.28.4] - 2026-04-13
+
+### Fixed
+- Filter forwarded Claude `--max-tokens` CLI args when the installed Claude CLI does not advertise support, preventing explicit passthrough flags from reintroducing unsupported-option failures.
+
+## [0.28.3] - 2026-04-13
+
+### Fixed
+- Guarded Claude CLI `--max-tokens` usage so commit-generation flows skip the flag on unsupported Claude versions while preserving it when available.
+
+### Technical
+- Added command-construction coverage for supported and unsupported Claude `--max-tokens` capability paths.
+
+## [0.28.2] - 2026-04-13
+
+### Technical
+- Tightened the package version contract test to require a full semantic-version match instead of accepting partial matches.
+## [0.28.1] - 2026-04-13
+
+### Changed
+- Completed the batch i05 migration follow-through for this package and aligned it with the restarted `fast` / `feat` / `e2e` verification model.
+
+### Technical
+- Included in the coordinated assignment-driven patch release for batch i05 package updates.
+
+
+### Changed
+- Migrated package tests to the `fast` / `feat` / `e2e` model and moved deterministic coverage into `test/fast` and `test/feat`.
+- Updated `TS-LLMCLI-001` scenario metadata and decision records to reference deterministic fast coverage locations.
+- Updated README testing guidance to teach the `ace-test ...`, `ace-test ... feat`, `ace-test ... all`, and `ace-test-e2e ...` contract.
+
+## [0.27.3] - 2026-04-10
+
+### Fixed
+- Forwarded `subprocess_env` into Codex and Gemini `SafeCapture` execution.
+- Updated Gemini prompt-cache and subprocess working-dir resolution to use execution context directly.
+
+### Technical
+- Added Codex and Gemini regression coverage to assert `SafeCapture` receives forwarded `env`.
+
 ## [0.27.2] - 2026-03-29
 
 ### Technical

data/README.md

@@ -14,9 +14,12 @@
 
 > Works with: Claude Code, Codex CLI, OpenCode, Gemini CLI, pi-agent, and more.
 
-[ace-llm Usage Guide](../ace-llm/docs/usage.md) | [ace-llm Handbook](../ace-llm/docs/handbook.md)
+[ace-llm Usage Guide](../ace-llm/docs/usage.md) | [ace-llm Handbook](../ace-llm/docs/handbook.md) | Part of [ACE](https://github.com/cs3b/ace)
+
 `ace-llm-providers-cli` extends [ace-llm](../ace-llm) with provider clients that execute through installed CLI tools (Claude, Codex, OpenCode, Gemini, pi, Codex OSS) while preserving the shared command interface. Provider defaults live in versioned YAML, and a health-check command verifies local readiness.
 
+This package intentionally does not ship a package-local `docs/` directory. Public usage and operator guidance live in the shared [ace-llm Usage Guide](../ace-llm/docs/usage.md), while `ace-llm-providers-cli-check --help` remains the authoritative runtime help surface for local readiness checks.
+
 ## How It Works
 
 1. The gem registers CLI provider clients on require, making them available to [ace-llm](../ace-llm) automatically.
@@ -31,6 +34,14 @@
 
 **Diagnose local provider readiness** - run `ace-llm-providers-cli-check` to verify that CLI tools are installed, authenticated, and reachable before starting work.
 
----
+## Testing
+
+- `ace-test ace-llm-providers-cli` runs deterministic fast coverage from `test/fast/`.
+- `ace-test ace-llm-providers-cli feat` runs deterministic feature coverage from `test/feat/`.
+- `ace-test ace-llm-providers-cli all` runs fast + feat deterministic coverage.
+- `ace-test-e2e ace-llm-providers-cli` runs retained workflow scenarios from `test/e2e/`.
+- E2E provider-discovery scenarios avoid helper interception: the no-tools path uses a baseline PATH
+  (`/usr/bin:/bin`), and success-path stubs are kept as text scripts in a dedicated sandbox stub directory.
 
-Part of [ACE](https://github.com/cs3b/ace)
+The package no longer uses legacy `test/integration` naming and does not use
+`ace-test ace-llm-providers-cli e2e` as a deterministic test path.

data/lib/ace/llm/providers/cli/atoms/command_formatters.rb

@@ -11,6 +11,9 @@ module Ace
 
             # Codex CLI: `/ace-git-commit` → `$ace-git-commit`
             CODEX_FORMATTER = ->(name) { "$#{name}" }
+
+            # Claude interactive CLI keeps slash commands unchanged.
+            CLAUDE_FORMATTER = ->(name) { "/#{name}" }
           end
         end
       end

data/lib/ace/llm/providers/cli/atoms/interactive_startup_policy.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+
+module Ace
+  module LLM
+    module Providers
+      module CLI
+        module Atoms
+          module InteractiveStartupPolicy
+            module_function
+
+            def tmux_context?(subprocess_env = nil)
+              env = normalized_env(subprocess_env)
+              !tmux_session_name(env).empty?
+            end
+
+            def codex_trust_override(working_dir:, subprocess_env: nil)
+              return nil unless tmux_context?(subprocess_env)
+
+              path = working_dir.to_s.strip
+              return nil if path.empty?
+
+              %{projects."#{escape_toml_basic_string(path)}".trust_level="trusted"}
+            end
+
+            def codex_overlay_home(working_dir:, subprocess_env: nil)
+              return nil unless tmux_context?(subprocess_env)
+
+              root = working_dir.to_s.strip
+              return nil if root.empty?
+
+              overlay_home = File.join(root, ".ace-local", "llm", "codex-home", Digest::SHA256.hexdigest(root)[0, 12])
+              prepare_codex_overlay_home(overlay_home: overlay_home, working_dir: root)
+              overlay_home
+            end
+
+            def normalized_env(subprocess_env)
+              env = ENV.to_h
+              return env unless subprocess_env
+
+              subprocess_env.each_with_object(env) do |(key, value), memo|
+                memo[key.to_s] = value
+              end
+            end
+
+            def tmux_session_name(env)
+              explicit = env["ACE_TMUX_SESSION"].to_s.strip
+              return explicit unless explicit.empty?
+
+              env["TMUX"].to_s.strip
+            end
+
+            def escape_toml_basic_string(value)
+              value.to_s.gsub("\\", "\\\\\\\\").gsub("\"", "\\\\\"")
+            end
+
+            def prepare_codex_overlay_home(overlay_home:, working_dir:)
+              codex_dir = File.join(overlay_home, ".codex")
+              FileUtils.mkdir_p(codex_dir)
+
+              sync_codex_overlay_links(codex_dir)
+              write_codex_overlay_config(codex_dir: codex_dir, working_dir: working_dir)
+            end
+
+            def sync_codex_overlay_links(codex_dir)
+              source_dir = File.expand_path("~/.codex")
+              return unless Dir.exist?(source_dir)
+
+              %w[auth.json installation_id version.json skills rules memories].each do |entry|
+                source = File.join(source_dir, entry)
+                next unless File.exist?(source)
+
+                target = File.join(codex_dir, entry)
+                next if File.exist?(target) || File.symlink?(target)
+
+                File.symlink(source, target)
+              end
+            end
+
+            def write_codex_overlay_config(codex_dir:, working_dir:)
+              source_config = File.expand_path("~/.codex/config.toml")
+              base = File.exist?(source_config) ? File.read(source_config) : ""
+              trust_block = <<~TOML
+
+                [projects."#{escape_toml_basic_string(working_dir)}"]
+                trust_level = "trusted"
+              TOML
+
+              target = File.join(codex_dir, "config.toml")
+              content = base.include?(trust_block.strip) ? base : "#{base.rstrip}#{trust_block}"
+              File.write(target, content)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/llm/providers/cli/claude_code_client.rb

@@ -6,6 +6,9 @@ require "shellwords"
 
 require_relative "cli_args_support"
 require_relative "atoms/execution_context"
+require_relative "atoms/command_rewriter"
+require_relative "atoms/command_formatters"
+require_relative "molecules/skill_name_reader"
 
 module Ace
   module LLM
@@ -33,6 +36,7 @@ module Ace
             # Skip normal BaseClient initialization that requires API key
             @options = options
             @generation_config = options[:generation_config] || {}
+            @skill_name_reader = Molecules::SkillNameReader.new
           end
 
           # Override to indicate this client doesn't need API credentials
@@ -60,7 +64,8 @@ module Ace
               cmd,
               prompt,
               subprocess_env: subprocess_env,
-              working_dir: working_dir
+              working_dir: working_dir,
+              subprocess_command_prefix: options[:subprocess_command_prefix]
             )
 
             parse_claude_response(stdout, stderr, status, prompt, options)
@@ -79,6 +84,32 @@ module Ace
             ]
           end
 
+          def interactive_supported?
+            true
+          end
+
+          def build_interactive_invocation(messages, **options)
+            validate_claude_availability!
+
+            prompt = format_messages_as_prompt(messages)
+            subprocess_env = options[:subprocess_env]
+            working_dir = Atoms::ExecutionContext.resolve_working_dir(
+              working_dir: options[:working_dir],
+              subprocess_env: subprocess_env
+            )
+            prompt = rewrite_skill_commands(prompt, working_dir: working_dir)
+
+            cmd = build_claude_interactive_command(prompt, options)
+            env = {"CLAUDECODE" => nil}
+            env.merge!(subprocess_env) if subprocess_env
+            {
+              command: cmd,
+              env: env,
+              working_dir: working_dir,
+              prompt: prompt
+            }
+          end
+
           private
 
           def format_messages_as_prompt(messages)
@@ -146,19 +177,42 @@ module Ace
             # (128KB per-argument limit). System content is already embedded in the
             # formatted prompt via format_messages_as_prompt.
 
+            cli_args = normalized_cli_args(options)
+            max_tokens_requested = cli_args_include_max_tokens_flag?(cli_args)
+
             # Add max tokens if provided
             max_tokens = options[:max_tokens] || @generation_config[:max_tokens]
             if max_tokens
-              cmd << "--max-tokens" << max_tokens.to_s
+              max_tokens_requested = true
+              cmd.concat(["--max-tokens", max_tokens.to_s]) if supports_max_tokens_flag?
             end
 
             # User CLI args last so they take precedence (last-wins in most CLIs)
-            cmd.concat(normalized_cli_args(options))
+            cmd.concat(filter_unsupported_cli_args(cli_args, max_tokens_requested: max_tokens_requested))
+
+            cmd
+          end
+
+          def build_claude_interactive_command(prompt, options)
+            cmd = ["claude"]
 
+            if @model && @model != DEFAULT_MODEL
+              cmd << "--model" << @model
+            end
+
+            cmd.concat(
+              normalized_cli_args_without_conflicts(
+                options,
+                forbidden_flags: ["-p", "--print", "--output-format", "--input-format", "--json-schema",
+                  "--include-partial-messages", "--include-hook-events", "--no-session-persistence"],
+                label: "Claude"
+              )
+            )
+            cmd << prompt.to_s unless prompt.to_s.empty?
             cmd
           end
 
-          def execute_claude_command(cmd, prompt, subprocess_env: nil, working_dir: nil)
+          def execute_claude_command(cmd, prompt, subprocess_env: nil, working_dir: nil, subprocess_command_prefix: nil)
             timeout_val = @options[:timeout] || 120
             # Clear CLAUDECODE env var so `claude -p` (non-interactive, one-shot mode)
             # can run as a subprocess from within a Claude Code session.
@@ -173,10 +227,58 @@ module Ace
               stdin_data: prompt.to_s,
               chdir: working_dir,
               env: env,
+              command_prefix: subprocess_command_prefix,
               provider_name: "Claude"
             )
           end
 
+          def supports_max_tokens_flag?
+            return @supports_max_tokens_flag unless @supports_max_tokens_flag.nil?
+
+            @supports_max_tokens_flag = command_help_supports_flag?("--max-tokens")
+          end
+
+          def command_help_supports_flag?(flag)
+            [["claude", "-p", "--help"], ["claude", "--help"]].any? do |help_cmd|
+              stdout, stderr, status = Open3.capture3({"CLAUDECODE" => nil}, *help_cmd)
+              status.success? && [stdout, stderr].join("\n").include?(flag)
+            rescue
+              false
+            end
+          end
+
+          def cli_args_include_max_tokens_flag?(cli_args)
+            cli_args.each_with_index.any? do |arg, index|
+              arg == "--max-tokens" || arg.start_with?("--max-tokens=") || (arg == "--max-tokens" && !cli_args[index + 1].nil?)
+            end
+          end
+
+          def filter_unsupported_cli_args(cli_args, max_tokens_requested: false)
+            return cli_args unless max_tokens_requested
+            return cli_args if supports_max_tokens_flag?
+
+            filtered = []
+            skip_next = false
+
+            cli_args.each do |arg|
+              if skip_next
+                skip_next = false
+                next
+              end
+
+              if arg == "--max-tokens"
+                skip_next = true
+                next
+              end
+
+              next if arg.start_with?("--max-tokens=")
+
+              filtered << arg
+            end
+
+            filtered
+          end
+
           def parse_claude_response(stdout, stderr, status, prompt, options)
             unless status.success?
               error_msg = stderr.empty? ? stdout : stderr
@@ -212,6 +314,29 @@ module Ace
             }
           end
 
+          def rewrite_skill_commands(prompt, working_dir: nil)
+            skills_dir = resolve_skills_dir(working_dir: working_dir)
+            return prompt unless skills_dir
+
+            skill_names = @skill_name_reader.call(skills_dir)
+            return prompt if skill_names.empty?
+
+            Atoms::CommandRewriter.call(
+              prompt,
+              skill_names: skill_names,
+              formatter: Atoms::CommandFormatters::CLAUDE_FORMATTER
+            )
+          end
+
+          def resolve_skills_dir(working_dir: nil)
+            configured = @options[:skills_dir] || @generation_config[:skills_dir]
+            return configured if configured && Dir.exist?(configured)
+
+            working_dir ||= Atoms::ExecutionContext.resolve_working_dir
+            candidate_dir = File.join(working_dir, ".claude", "skills")
+            candidate_dir if Dir.exist?(candidate_dir)
+          end
+
           def extract_claude_text(response)
             direct_result = response["result"]
             direct_response = response["response"]

data/lib/ace/llm/providers/cli/claude_oai_client.rb

@@ -61,7 +61,8 @@ module Ace
               cmd,
               prompt,
               subprocess_env: subprocess_env,
-              working_dir: working_dir
+              working_dir: working_dir,
+              subprocess_command_prefix: options[:subprocess_command_prefix]
             )
 
             parse_claude_response(stdout, stderr, status, prompt, options)
@@ -154,7 +155,7 @@ module Ace
             cmd
           end
 
-          def execute_claude_command(cmd, prompt, subprocess_env: nil, working_dir: nil)
+          def execute_claude_command(cmd, prompt, subprocess_env: nil, working_dir: nil, subprocess_command_prefix: nil)
             timeout_val = @options[:timeout] || 120
 
             # Build env with backend-specific vars for Anthropic-compatible routing
@@ -169,6 +170,7 @@ module Ace
               stdin_data: prompt.to_s,
               chdir: working_dir,
               env: env,
+              command_prefix: subprocess_command_prefix,
               provider_name: "Claude OAI"
             )
           end

data/lib/ace/llm/providers/cli/cli_args_support.rb

@@ -12,6 +12,21 @@ module Ace
           def normalized_cli_args(options)
             Atoms::ArgsNormalizer.new.normalize_cli_args(options[:cli_args])
           end
+
+          def normalized_cli_args_without_conflicts(options, forbidden_flags:, label:)
+            args = normalized_cli_args(options)
+            conflict = find_conflicting_cli_arg(args, forbidden_flags)
+            return args unless conflict
+
+            raise Ace::LLM::ProviderError, "#{label} interactive mode does not support cli arg #{conflict}"
+          end
+
+          def find_conflicting_cli_arg(args, forbidden_flags)
+            normalized_forbidden = Array(forbidden_flags).map(&:to_s)
+            args.find do |arg|
+              normalized_forbidden.any? { |flag| arg == flag || arg.start_with?("#{flag}=") }
+            end
+          end
         end
       end
     end

data/lib/ace/llm/providers/cli/codex_client.rb

@@ -8,6 +8,7 @@ require_relative "cli_args_support"
 require_relative "atoms/execution_context"
 require_relative "atoms/command_rewriter"
 require_relative "atoms/command_formatters"
+require_relative "atoms/interactive_startup_policy"
 require_relative "atoms/worktree_dir_resolver"
 require_relative "molecules/skill_name_reader"
 
@@ -30,7 +31,7 @@ module Ace
           end
 
           # Default model (can be overridden by config)
-          DEFAULT_MODEL = "gpt-5"
+          DEFAULT_MODEL = "gpt-5.4"
 
           def initialize(model: nil, **options)
             @model = model || DEFAULT_MODEL
@@ -74,11 +75,48 @@ module Ace
             # Return models based on what the CLI supports
             # Actual models come from YAML config
             [
-              {id: "gpt-5", name: "GPT-5", description: "Advanced Codex model", context_size: 128_000},
-              {id: "gpt-5-mini", name: "GPT-5 Mini", description: "Smaller, faster model", context_size: 128_000}
+              {id: "gpt-5.3-codex", name: "GPT-5.3 Codex", description: "Code-specialized Codex model", context_size: 128_000},
+              {id: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark", description: "Faster Codex model", context_size: 128_000},
+              {id: "gpt-5.4", name: "GPT-5.4", description: "Advanced Codex model", context_size: 128_000},
+              {id: "gpt-5.4-mini", name: "GPT-5.4 Mini", description: "Smaller, faster Codex model", context_size: 128_000}
             ]
           end
 
+          def interactive_supported?
+            true
+          end
+
+          def build_interactive_invocation(messages, **options)
+            validate_codex_availability!
+
+            prompt = format_messages_as_prompt(messages)
+            subprocess_env = options[:subprocess_env]
+            working_dir = Atoms::ExecutionContext.resolve_working_dir(
+              working_dir: options[:working_dir],
+              subprocess_env: subprocess_env
+            )
+            prompt = rewrite_skill_commands(prompt, working_dir: working_dir)
+
+            env = subprocess_env ? subprocess_env.to_h.dup : {}
+            overlay_home = Atoms::InteractiveStartupPolicy.codex_overlay_home(
+              working_dir: working_dir,
+              subprocess_env: subprocess_env
+            )
+            env["HOME"] = overlay_home if overlay_home
+
+            cmd = build_codex_interactive_command(
+              prompt,
+              options,
+              working_dir: working_dir
+            )
+            {
+              command: cmd,
+              env: env,
+              working_dir: working_dir,
+              prompt: prompt
+            }
+          end
+
           private
 
           def format_messages_as_prompt(messages)
@@ -182,6 +220,36 @@ module Ace
             cmd
           end
 
+          def build_codex_interactive_command(prompt, options, working_dir: nil)
+            working_dir ||= Atoms::ExecutionContext.resolve_working_dir(
+              working_dir: options[:working_dir],
+              subprocess_env: options[:subprocess_env]
+            )
+            cmd = ["codex"]
+
+            if options[:sandbox]
+              cmd << "--sandbox" << options[:sandbox].to_s
+            end
+
+            if @model && @model != DEFAULT_MODEL
+              cmd << "--model" << @model
+            end
+
+            if (git_dir = Atoms::WorktreeDirResolver.call(working_dir: working_dir))
+              cmd << "--add-dir" << git_dir
+            end
+
+            cmd.concat(
+              normalized_cli_args_without_conflicts(
+                options,
+                forbidden_flags: ["exec", "review", "--output-last-message"],
+                label: "Codex"
+              )
+            )
+            cmd << prompt.to_s unless prompt.to_s.empty?
+            cmd
+          end
+
           def execute_codex_command(cmd, prompt, options)
             # Prepare the input - combine system prompt with user prompt if needed
             input = prompt.to_s
@@ -206,6 +274,8 @@ module Ace
               timeout: timeout_val,
               stdin_data: input,
               chdir: working_dir,
+              env: options[:subprocess_env],
+              command_prefix: options[:subprocess_command_prefix],
               provider_name: "Codex"
             )
           end

data/lib/ace/llm/providers/cli/codex_oai_client.rb

@@ -197,6 +197,8 @@ module Ace
               timeout: timeout_val,
               stdin_data: input,
               chdir: working_dir,
+              env: options[:subprocess_env],
+              command_prefix: options[:subprocess_command_prefix],
               provider_name: "Codex OAI"
             )
           end

data/lib/ace/llm/providers/cli/gemini_client.rb

@@ -245,7 +245,11 @@ module Ace
           end
 
           def create_prompt_cache_dir(working_dir = nil, subprocess_env: nil)
-            cache_dir = File.join(find_project_root(working_dir, subprocess_env: subprocess_env), ".ace-local", "llm", "prompts")
+            resolved_working_dir = Atoms::ExecutionContext.resolve_working_dir(
+              working_dir: working_dir,
+              subprocess_env: subprocess_env
+            )
+            cache_dir = File.join(resolved_working_dir, ".ace-local", "llm", "prompts")
             FileUtils.mkdir_p(cache_dir) unless Dir.exist?(cache_dir)
             cache_dir
           end
@@ -256,17 +260,18 @@ module Ace
 
           def execute_gemini_command(cmd, prompt, options)
             timeout_val = options[:timeout] || @options[:timeout] || 120
-            project_root = find_project_root(options[:working_dir], subprocess_env: options[:subprocess_env])
-            Molecules::SafeCapture.call(cmd, timeout: timeout_val, chdir: project_root, provider_name: "Gemini")
-          end
-
-          def find_project_root(working_dir = nil, subprocess_env: nil)
-            require "ace/support/fs"
-            start_path = Atoms::ExecutionContext.resolve_working_dir(
-              working_dir: working_dir,
-              subprocess_env: subprocess_env
+            working_dir = Atoms::ExecutionContext.resolve_working_dir(
+              working_dir: options[:working_dir],
+              subprocess_env: options[:subprocess_env]
+            )
+            Molecules::SafeCapture.call(
+              cmd,
+              timeout: timeout_val,
+              chdir: working_dir,
+              env: options[:subprocess_env],
+              command_prefix: options[:subprocess_command_prefix],
+              provider_name: "Gemini"
             )
-            Ace::Support::Fs::Molecules::ProjectRootFinder.find(start_path: start_path) || start_path
           end
 
           def parse_gemini_response(stdout, stderr, status, prompt, options)

data/lib/ace/llm/providers/cli/molecules/safe_capture.rb

@@ -27,13 +27,15 @@ module Ace
             # @return [Array(String, String, Process::Status)] [stdout, stderr, status]
             # @raise [Ace::LLM::ProviderError] on timeout
             def self.call(cmd, timeout:, stdin_data: nil, chdir: nil, env: nil, provider_name: "CLI",
+              command_prefix: nil,
               isolate_process_group: true, cleanup_group_on_exit: true)
               normalized_timeout = normalize_timeout(timeout)
               opts = {}
               opts[:chdir] = chdir if chdir
               opts[:pgroup] = true if isolate_process_group
 
-              args = env ? [env, *cmd] : cmd
+              full_cmd = Array(command_prefix) + cmd
+              args = env ? [env, *full_cmd] : full_cmd
 
               Open3.popen3(*args, **opts) do |stdin, stdout, stderr, wait_thr|
                 pid = wait_thr.pid

data/lib/ace/llm/providers/cli/open_code_client.rb

@@ -205,6 +205,8 @@ module Ace
               timeout: timeout_val,
               stdin_data: "",
               chdir: working_dir,
+              env: options[:subprocess_env],
+              command_prefix: options[:subprocess_command_prefix],
               provider_name: "OpenCode"
             )
           end

data/lib/ace/llm/providers/cli/pi_client.rb

@@ -57,7 +57,7 @@ module Ace
             full_prompt = rewrite_skill_commands(full_prompt, working_dir: working_dir)
 
             cmd = build_pi_command(full_prompt, options, system_prompt: system_prompt)
-            stdout, stderr, status = execute_pi_command(cmd, working_dir: working_dir)
+            stdout, stderr, status = execute_pi_command(cmd, working_dir: working_dir, options: options)
 
             parse_pi_response(stdout, stderr, status, full_prompt, options)
           rescue => e
@@ -77,6 +77,31 @@ module Ace
             ]
           end
 
+          def interactive_supported?
+            true
+          end
+
+          def build_interactive_invocation(messages, **options)
+            validate_pi_availability!
+
+            prompt = format_messages_as_prompt(messages)
+            full_prompt, system_prompt = build_full_prompt(prompt, options)
+            subprocess_env = options[:subprocess_env]
+            working_dir = Atoms::ExecutionContext.resolve_working_dir(
+              working_dir: options[:working_dir],
+              subprocess_env: subprocess_env
+            )
+            full_prompt = rewrite_skill_commands(full_prompt, working_dir: working_dir)
+
+            cmd = build_pi_interactive_command(full_prompt, options, system_prompt: system_prompt)
+            {
+              command: cmd,
+              env: subprocess_env,
+              working_dir: working_dir,
+              prompt: full_prompt
+            }
+          end
+
           private
 
           def format_messages_as_prompt(messages)
@@ -178,6 +203,31 @@ module Ace
             cmd
           end
 
+          def build_pi_interactive_command(full_prompt, options, system_prompt: nil)
+            cmd = ["pi"]
+
+            if system_prompt
+              cmd << "--system-prompt" << system_prompt
+            end
+
+            model_to_use = @model || @generation_config[:model] || DEFAULT_MODEL
+            provider_name, model_id = split_provider_model(model_to_use)
+            if provider_name && model_id
+              cmd << "--provider" << provider_name
+              cmd << "--model" << model_id
+            end
+
+            cmd.concat(
+              normalized_cli_args_without_conflicts(
+                options,
+                forbidden_flags: ["-p", "--print", "--no-session", "--no-skills", "--mode"],
+                label: "Pi"
+              )
+            )
+            cmd << full_prompt.to_s unless full_prompt.to_s.empty?
+            cmd
+          end
+
           # Split "provider/model" into ["provider", "model"]
           # Handles multi-segment providers like "google-gemini-cli/gemini-2.5-pro"
           # Also handles nested providers like "openrouter:openai/gpt-oss-120b"
@@ -200,13 +250,15 @@ module Ace
             [parts[0], parts[1]]
           end
 
-          def execute_pi_command(cmd, timeout: nil, working_dir: nil)
+          def execute_pi_command(cmd, timeout: nil, working_dir: nil, options: {})
             timeout_val = timeout || @options[:timeout] || 120
             Molecules::SafeCapture.call(
               cmd,
               timeout: timeout_val,
               stdin_data: "",
               chdir: working_dir,
+              env: options[:subprocess_env],
+              command_prefix: options[:subprocess_command_prefix],
               provider_name: "Pi"
             )
           end

data/lib/ace/llm/providers/cli/version.rb

@@ -4,7 +4,7 @@ module Ace
   module LLM
     module Providers
       module CLI
-        VERSION = '0.27.2'
+        VERSION = '0.31.2'
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-llm-providers-cli
 version: !ruby/object:Gem::Version
-  version: 0.27.2
+  version: 0.31.2
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-03-29 00:00:00.000000000 Z
+date: 2026-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-llm
@@ -91,6 +91,7 @@ files:
 - lib/ace/llm/providers/cli/atoms/command_formatters.rb
 - lib/ace/llm/providers/cli/atoms/command_rewriter.rb
 - lib/ace/llm/providers/cli/atoms/execution_context.rb
+- lib/ace/llm/providers/cli/atoms/interactive_startup_policy.rb
 - lib/ace/llm/providers/cli/atoms/provider_detector.rb
 - lib/ace/llm/providers/cli/atoms/session_finders/claude_session_finder.rb
 - lib/ace/llm/providers/cli/atoms/session_finders/codex_session_finder.rb