v1.5.4: Remove unused feature flags and oz-platform skill

Remove cloud/sharing feature flags (viewing_shared_sessions, shared_with_me, session_sharing_acls, shared_block_title_generation, agent_shared_sessions, cloud_environments, cloud_conversations, etc.) and classic_completions flags. Remove oz-platform skill. Update blocklist views and drive index. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-05-28 11:02:41 -05:00
parent 1fee031ea5
commit d9bdafed0a
8 changed files with 53 additions and 531 deletions
@@ -5191,7 +5191,7 @@ dependencies = [
 [[package]]
 name = "galaxy"
-version = "1.5.2"
+version = "1.5.3"
 dependencies = [
 "addr",
 "aho-corasick",
@@ -461,14 +461,11 @@ cross_repo_context = []
 codebase_index_persistence = ["full_source_code_embedding"]
 default = [
    "agent_mode",
    "viewing_shared_sessions",
    "render_continuous_block_selections_with_single_border",
    "settings_import",
    "shared_with_me",
    "block_toolbelt_save_as_workflow",
    "remove_alt_screen_padding",
    "less_horizontal_terminal_padding",
    "session_sharing_acls",
    "external_agent_mode_context",
    "shell_selector",
    "minimalist_ui",
@@ -507,7 +504,6 @@ default = [
    "agent_management_view",
    "agent_management_details_view",
    "interactive_conversation_management_view",
    "shared_block_title_generation",
    "tab_close_button_on_left",
    "ai_resume_button",
    "code_find_replace",
@@ -545,39 +541,22 @@ default = [
    "summarize_conversation_command",
    "inline_code_review",
    "web_search_ui",
    "agent_shared_sessions",
    "integration_command",
    "artifact_command",
    "cloud_environments",
    "create_environment_slash_command",
    "code_review_find",
    "shared_session_long_running_commands",
    "mcp_grouped_server_context",
    "fork_from_command",
    "context_window_usage_v2",
    "ambient_agents_command_line",
    "ambient_agents_image_upload",
    "scheduled_ambient_agents",
    "galaxy_managed_secrets",
    "v4a_file_diffs",
    "classic_completions",
    "force_classic_completions",
    "team_api_keys",
    "agent_tips",
    "pluggable_notifications",
    "agent_onboarding",
    "global_search",
    "cloud_conversations",
    "list_skills",
    "ask_user_question",
    "bundled_skills",
    "ambient_agents_rtc",
    "cloud_mode",
    "cloud_mode_from_local_session",
    "cloud_mode_image_context",
    "agent_mode_computer_use",
    "oz_platform_skills",
    "sync_ambient_plans",
    "conversation_artifacts",
    "agent_view",
    "agent_view_block_context",
@@ -585,13 +564,10 @@ default = [
    "inline_slash_commands",
    "inline_history_menu",
    "inline_model_selector",
    "oz_launch_modal",
    "open_warp_launch_modal",
    "new_tab_styling",
    "richtext_multiselect",
    "inline_profile_selector",
    "web_fetch_ui",
    "oz_changelog_updates",
    "skill_arguments",
    "incremental_auto_reload",
    "active_conversation_requires_interaction",
@@ -612,21 +588,31 @@ default = [
    "rewind_slash_command",
    "hoa_code_review",
    "warpify_footer",
    "hoa_notifications",
    "hoa_onboarding_flow",
    "agent_toolbar_editor",
    "configurable_toolbar",
    "transfer_control_tool",
    "hoa_notifications",
    "open_code_notifications",
    "cli_agent_rich_input",
    "vertical_tabs",
    "tab_configs",
    "hoa_onboarding_flow",
    "hoa_remote_control",
    "codex_notifications",
    "trim_trailing_blank_lines",
    "open_warp_new_settings_modes",
    "skip_firebase_anonymous_user",
    "settings_file",
    "queue_slash_command",
    "pending_user_query_indicator",
    "orchestration",
    "orchestration_v2",
    "lsp_as_a_tool",
    "cross_repo_context",
    "completions_v2",
    "voice_input",
    "drag_tabs_to_windows",
    "plugin_host",
    "file_and_diff_set_comments",
 ]
 # Enable this feature to automatically perform heap profiling.  NOTE: This will
 # substantially slow down program execution.
@@ -3239,6 +3239,7 @@ fn render_usage_button(props: Props, app: &AppContext) -> Box<dyn Element> {
    let current_context = conversation.current_context_tokens();
    let cache_read = conversation.total_cache_read_tokens();
    let cache_write = conversation.total_cache_write_tokens();
    let total_input = conversation.total_input_tokens();
    let cost_cents = conversation.total_cost_cents();
    let max_context: u32 = if context_usage > 0.0 {
@@ -3247,21 +3248,22 @@ fn render_usage_button(props: Props, app: &AppContext) -> Box<dyn Element> {
        200_000
    };
    let context_pct = context_usage * 100.0;
-    let cache_total = cache_read + cache_write;
+    let cache_total_ops = cache_read + cache_write + total_input;
-    let cache_hit_pct = if cache_total > 0 {
+    let cache_hit_pct = if cache_total_ops > 0 {
-        (cache_read as f64 / cache_total as f64) * 100.0
+        (cache_read as f64 / cache_total_ops as f64) * 100.0
    } else {
        0.0
    };
    let usage_text = format!(
-        "Context: {:.1}% ({} / {}) | Cache: {:.1}% (R: {}, W: {}) | Cost: ${:.2}",
+        "Context: {:.1}% ({} / {}) | Cache Hit: {:.1}% (R: {}, W: {}, M: {}) | Cost: ${:.2}",
        context_pct,
        format_token_count(current_context),
        format_token_count(max_context),
        cache_hit_pct,
        format_token_count(cache_read),
        format_token_count(cache_write),
        format_token_count(total_input),
        cost_cents / 100.0,
    );
@@ -280,15 +280,18 @@ impl ConversationUsageView {
                ));
            }
-            // Cache hit rate: proportion of total input tokens served from cache
+            // Cache hit rate: cache_reads / (cache_reads + cache_writes + cache_misses)
-            let total_input = self.usage_info.total_input_tokens;
+            // where cache_misses = total_input_tokens (non-cached input)
-            if total_input > 0 && self.usage_info.total_cache_read_tokens > 0 {
+            let total_cache_ops = self.usage_info.total_cache_read_tokens
                + self.usage_info.total_cache_write_tokens
                + self.usage_info.total_input_tokens;
            if total_cache_ops > 0 && self.usage_info.total_cache_read_tokens > 0 {
                let hit_rate = (self.usage_info.total_cache_read_tokens as f32
-                    / total_input as f32)
+                    / total_cache_ops as f32)
                    * 100.0;
                labels.push(render_label_text("Cache hit rate", appearance));
                values.push(render_value_text(
-                    format!("{:.0}%", hit_rate.min(100.0)),
+                    format!("{:.1}%", hit_rate),
                    appearance,
                ));
            }
@@ -1051,6 +1051,24 @@ impl DriveIndex {
        false
    }
    fn can_trash_or_delete(
        &self,
        cloud_object_type_and_id: &CloudObjectTypeAndId,
        app: &AppContext,
    ) -> bool {
        if let Some(object) = CloudModel::as_ref(app).get_by_uid(&cloud_object_type_and_id.uid()) {
            if !object.metadata().has_pending_online_only_change() {
                // Local-only objects can always be trashed/deleted.
                if !cloud_object_type_and_id.has_server_id() {
                    return true;
                }
                // Server-synced objects require online connectivity.
                return self.is_online(app);
            }
        }
        false
    }
    fn is_online(&self, app: &AppContext) -> bool {
        NetworkStatus::as_ref(app).is_online()
    }
@@ -4357,6 +4375,7 @@ impl DriveIndex {
            return menu_items;
        };
        let can_move_or_trash = self.online_only_operation_allowed(cloud_object_type_and_id, app);
        let can_trash = self.can_trash_or_delete(cloud_object_type_and_id, app);
        let cloud_view_model = CloudViewModel::as_ref(app);
        let access_level = cloud_view_model.access_level(&cloud_object_type_and_id.uid(), app);
        let editability = cloud_view_model.object_editability(&cloud_object_type_and_id.uid(), app);
@@ -4754,7 +4773,7 @@ impl DriveIndex {
            }
        }
-        if can_move_or_trash
+        if can_trash
            && (!FeatureFlag::SharedWithMe.is_enabled() || access_level.can_trash())
        {
            menu_items.push(
@@ -4823,7 +4842,7 @@ impl DriveIndex {
            }
        }
-        if self.online_only_operation_allowed(cloud_object_type_and_id, app) {
+        if self.can_trash_or_delete(cloud_object_type_and_id, app) {
            if !FeatureFlag::SharedWithMe.is_enabled() || access_level.can_trash() {
                menu_items.push(
                    MenuItemFields::new("Restore")
@@ -4211,12 +4211,14 @@ impl UpdateManager {
    }
    pub fn trash_object(&mut self, id: CloudObjectTypeAndId, ctx: &mut ModelContext<Self>) {
-        // // If the object isn't known to the server yet, we can't trash it.
+        let hashed_id = id.uid();
        // If the object isn't known to the server, delete it permanently (no server-side trash).
        let Some(server_id) = id.server_id() else {
            self.delete_object_by_user(id, ctx);
            return;
        };
        let hashed_id = id.uid();
        // If there's a pending online-only operation for this object, don't trash it.
        let Some(has_pending_online_only_operation) =
            CloudModel::handle(ctx).read(ctx, |model, _| {
@@ -1,273 +0,0 @@
 ---
 name: oz-platform
 description: Use Warp's REST API and command line to run, configure, and inspect Oz cloud agents
 ---
 # oz-platform
 Use the Oz REST API and CLI to:
 * Spawn cloud agents
 * Get the status of a cloud agent
 * Schedule cloud agents to run repeatedly
 * Create and manage the environments in which cloud agents run
 * Provide secrets for cloud agents to use
 ## Command Line
 The Oz CLI is installed as `{{warp_cli_binary_name}}`. To get help output, use `{{warp_cli_binary_name}} help` or `{{warp_cli_binary_name}} help <subcommand>`.
 Prefer `--output-format text` to review the response, or `--output-format json` to parse fields with `jq`.
 You can find more information at https://docs.warp.dev/reference/cli.
 The most important commands are:
 * `{{warp_cli_binary_name}} agent run-cloud`: Spawn a new cloud agent. You can configure the prompt, model, environment, and other settings.
 * `{{warp_cli_binary_name}} run list` and `{{warp_cli_binary_name}} run get <run-id>`: List all cloud agent runs, and get details about a particular run.
 * `{{warp_cli_binary_name}} environment list` and `{{warp_cli_binary_name}} environment get`: List available environments, and get more information about a particular environment.
 * `{{warp_cli_binary_name}} schedule list` and `{{warp_cli_binary_name}} schedule get`: List scheduled tasks with most recent runs, and get more information about a particular scheduled run.
 Most subcommands support the `--output-format json` flag to produce JSON output, which you can pipe into `jq` or other commands.
 ### Examples
 Start a cloud agent, and then monitor its status:
 ```sh
 $ {{warp_cli_binary_name}} agent run-cloud --prompt "Update the login error to be more specific" --environment UA17BXYZ
 # ...
 Spawned agent with run ID: 5972cca4-a410-42af-930a-e56bc23e07ac
 ```
 ```sh
 $ {{warp_cli_binary_name}} run get 5972cca4-a410-42af-930a-e56bc23e07ac
 # ...
 ```
 Schedule an agent to summarize feedback every day at 8am UTC:
 ```sh
 $ {{warp_cli_binary_name}} schedule create --cron "0 8 * * *" \
    --prompt "Collect all feedback from new GitHub issues and provide a summary report" \
    --environment UA17BXYZ
 ```
 Create a secret for cloud agents to use:
 ```sh
 $ {{warp_cli_binary_name}} secret create JIRA_API_KEY --team --value-file jira_key.txt --description "API key to access Jira"
 ```
 ## REST API
 Oz has a REST API for starting and inspecting cloud agents.
 All API requests require authentication using an API key. The user can generate API keys in their Warp settings, on the `Platform` page (accessible via `{{warp_url_scheme}}://settings/platform`).
 You can find the full OpenAPI specification here: https://docs.warp.dev/reference/api-and-sdk
 ### TypeScript / JavaScript SDK
 The TypeScript SDK is available via NPM. It is fully async, and works with Node, Bun, and Deno.
 * Package link: https://www.npmjs.com/package/oz-agent-sdk
 * Source Code: https://github.com/warpdotdev/oz-sdk-typescript
 * API reference: https://raw.githubusercontent.com/warpdotdev/oz-sdk-typescript/HEAD/api.md
 ### Python SDK
 The Python SDK is available from PyPi. It can be used synchronously or asynchronously.
 * Package link: https://pypi.org/project/oz-agent-sdk/
 * Source Code: https://github.com/warpdotdev/oz-sdk-python
 * API reference: https://raw.githubusercontent.com/warpdotdev/oz-sdk-python/refs/heads/main/api.md
 ### API Examples
 ```sh
 curl -L -X POST {{warp_server_url}}/api/v1/agent/run \
    --header 'Authorization: Bearer YOUR_API_KEY' \
    --header 'Content-Type: application/json' \
    --data '{
        "prompt": "Update the login error to be more specific",
        "config": {
            "environment_id": "UA17BXYZ"
        }
    }'
 ```
 ```sh
 curl -L -X GET {{warp_server_url}}/api/v1/agent/runs/5972cca4-a410-42af-930a-e56bc23e07ac \
    --header 'Authorization: Bearer YOUR_API_KEY' \
    --header 'Content-Type: application/json'
 ```
 ## GitHub Actions Integration
 You can trigger Oz cloud agents from GitHub Actions workflows. This enables automation like:
 * Triaging issues when they're created or labeled
 * Running checks on pull requests
 * Scheduling periodic tasks via workflow dispatch
 The agent will have access to the `gh` CLI to communicate back to the repository. Prefer prompting the agent to use `gh` vs. requiring the agent to respond with structured output for the GitHub workflow to parse.
 ### Action Setup
 Use `warpdotdev/oz-agent-action@main` in your workflow. Required inputs:
 * `prompt`: The task description for the agent
 * `warp_api_key`: API key (store in GitHub secrets, e.g., `${{ secrets.WARP_API_KEY }}`)
 * `profile`: Optional agent profile identifier (can use repo variable, e.g., `${{ vars.WARP_AGENT_PROFILE || '' }}`)
 The action outputs `agent_output` with the agent's response.
 ### Minimal Workflow Example
 ```yaml
 name: Run Oz Agent
 on:
  issues:
    types: [opened, labeled]
 jobs:
  agent:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      issues: write
      pull-requests: write
    steps:
      - uses: actions/checkout@v6
      - uses: warpdotdev/oz-agent-action@main
        id: agent
        with:
          prompt: |
            Analyze the GitHub issue and provide a summary.
            Issue: ${{ github.event.issue.title }}
            ${{ github.event.issue.body }}
            Respond to the issue with a comment containing your summary using the `gh` CLI.
          warp_api_key: ${{ secrets.WARP_API_KEY }}
          profile: ${{ vars.WARP_AGENT_PROFILE || '' }}
      - name: Use Agent Output
        run: echo "${{ steps.agent.outputs.agent_output }}"
 ```
 ### Common Patterns
 **Conditional steps**: Use `if: steps.agent.outputs.agent_output` to branch on agent results.
 **Templating**: Use `actions/github-script@v7` to construct dynamic prompts from issue templates, repo context, or code.
 **Error handling**: Check action success with `if: success()` or `if: failure()`.
 **Git operations**: The action runs with checked-out code and Git credentials, so agents can commit and push changes.
 ## Environments
 All cloud agents run in an environment. The environment defines:
 * Which programs are preinstalled for the agent (based on a Docker image)
 * The Git repositories to check out before the agent starts
 * Setup commands to run, such as `npm install` or `cargo fetch`
 You should almost always run cloud agents in an environment. Otherwise, they may not have the necessary code or tools available.
 Cloud agents run in a sandbox, so they _can_ install additional programs into their environment. They also have Git credentials to create PRs and push branches.
 Cloud environments DO NOT store secret values, like API keys. Use the `{{warp_cli_binary_name}} secret` commands instead.
 ## Using Third-Party Coding CLIs
 Oz environments support running third-party coding agent CLIs such as Claude Code, Codex, Gemini CLI, Amp, Copilot CLI, and OpenCode. The `-agents` tagged variants of prebuilt Oz Docker images (e.g. `warpdotdev/dev-rust:1.85-agents`) come with the most popular CLIs preinstalled. Base tags (without `-agents`) do not include coding agent CLIs.
 For detailed per-CLI documentation (installation, authentication, non-interactive flags, and artifact reporting), see [references/third-party-clis.md](./references/third-party-clis.md).
 ### For Interactive Agents: Launching Cloud Agents with Third-Party CLIs
 When you are an interactive agent launching a cloud agent to use a third-party CLI:
 1. **Environment Selection**: First, ask the user which environment to use. Present the public `-agents` image options from [warpdotdev/oz-dev-environments](https://github.com/warpdotdev/oz-dev-environments):
   - `warpdotdev/dev-base:latest-agents`
   - `warpdotdev/dev-go:1.23-agents`
   - `warpdotdev/dev-rust:1.83-agents`
   - `warpdotdev/dev-rust:1.85-agents`
   - `warpdotdev/dev-java:21-agents`
   - `warpdotdev/dev-dotnet:8.0-agents`
   - `warpdotdev/dev-ruby:3.3-agents`
   - `warpdotdev/dev-web:latest-agents`
   - `warpdotdev/dev-full:latest-agents`
   Also ask if they want to use an existing environment instead. To list their environments:
   ```sh
   {{warp_cli_binary_name}} environment list --output-format text
   ```
   If they choose a public image without an existing environment, create one with `{{warp_cli_binary_name}} environment create ...`
 2. **Prompt Construction**: Construct a simple prompt that delegates CLI invocation to the cloud agent:
   ```sh
   {{warp_cli_binary_name}} agent run-cloud \
       --environment <ENV_ID> \
       --prompt 'Read the oz-platform skill for instructions on using [CLI name] to solve: <task description>'
   ```
   **Do not** include the CLI command syntax in the prompt. The cloud agent will read the oz-platform skill and follow those instructions.
 **Example**:
 ```sh
 $ {{warp_cli_binary_name}} agent run-cloud \
    --environment <ENV_ID> \
    --prompt 'Read the oz-platform skill for instructions on using Claude Code to solve: Summarize the architecture of this project'
 ```
 ### For Cloud Agents: Invoking Third-Party CLIs
 When you are a cloud agent instructed to use a third-party CLI:
 1. **Environment**: You are already running in an environment with the CLI preinstalled (if it's in an `-agents` image).
 2. **Authentication**: API keys are available as environment variables (e.g. `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`). These were configured as Oz secrets by the user.
 3. **Task Delegation (IMPORTANT)**: The user's task should be completed **entirely by the third-party CLI**. Do NOT use Warp's built-in tools to complete the task yourself:
   - Do NOT use `edit_files`, `read_files`, `grep`, `codebase_semantic_search`, or other Warp coding tools to perform the user's task
   - The third-party CLI should do all the coding, file editing, searching, and analysis work
   - Your role is to:
     - Set up the CLI (e.g., authenticate if needed)
     - Construct the prompt for the CLI with the user's task
     - Run the CLI and monitor its execution
     - Debug any issues with the CLI itself
     - Report artifacts back to Warp (see below)
 4. **CLI Invocation**: Read [references/third-party-clis.md](./references/third-party-clis.md) for detailed instructions on:
   - Non-interactive mode flags for each CLI (e.g. `claude -p`, `codex exec`, `gemini -p`)
   - Authentication setup steps if needed (e.g. Codex requires `printenv OPENAI_API_KEY | codex login --with-api-key`)
   - Useful flags and options
   - Example commands
 5. **Artifact Reporting**: When the third-party CLI creates a PR, parse its output for the PR URL and branch name, then call `report_pr` to register the artifact in the Warp UI.
 **Example workflow**:
 ```sh
 # 1. Read this skill and references/third-party-clis.md to understand CLI usage
 # 2. Set up authentication if needed (e.g., for Codex)
 # For Claude Code, ANTHROPIC_API_KEY is already available
 # 3. Run the CLI with the user's task - let it do ALL the work
 $ claude -p "Summarize the architecture of this project"
 # 4. If a PR was created, parse the CLI output and report the artifact
 # Example: report_pr(pr_url="https://github.com/...", branch="feature-branch")
 ```
 **What NOT to do**:
 ```sh
 # ❌ Don't read files yourself to help the CLI
 $ read_files ...
 # ❌ Don't search the codebase yourself
 $ grep ...
 # ❌ Don't edit files yourself
 $ edit_files ...
 # ✅ Instead, let the third-party CLI handle everything
 $ claude -p "Complete the entire task: <user's task>"
 ```
@@ -1,217 +0,0 @@
 # Third-Party Coding Agent CLIs
 **Context**: This reference is for cloud agents who need to invoke third-party coding CLIs. If you are an interactive agent launching a cloud agent, see the "For Interactive Agents" section in the main oz-platform skill instead.
 This reference documents third-party coding agent CLIs that Oz cloud agents can install and run. Each CLI has its own authentication, non-interactive mode, and nuances.
 The `-agents` tagged variants of prebuilt Oz Docker images (e.g. `warpdotdev/dev-base:latest-agents`, `warpdotdev/dev-rust:1.85-agents`) include Claude Code, Codex, and Gemini CLI preinstalled. Base tags (without `-agents`) do not include coding agent CLIs.
 > **Note**: Commands below that reference the Warp CLI should use the CLI binary name from the parent skill (the `{{warp_cli_binary_name}}` value).
 ## Reporting Artifacts
 When a third-party CLI creates a PR or branch, Oz does not automatically detect it. You must explicitly register these artifacts so they appear in the Warp UI.
 **Pull Requests**: After a third-party CLI creates a PR, call the `report_pr` tool with the `pr_url` and `branch` parameters. Parse the CLI's output to extract the PR URL and branch name.
 **How to prompt for this**: When writing prompts that instruct an Oz agent to delegate work to a third-party CLI, always include instructions to:
 1. Tell the third-party CLI to print the PR URL and branch name in its output.
 2. After the CLI finishes, parse the output and call `report_pr` to register the artifact.
 **Plans**: Plan artifacts are registered automatically by the Oz agent when it creates plans using its built-in plan tools. No special handling is needed.
 ---
 ## Claude Code
 - **Package**: `npm install -g @anthropic-ai/claude-code`
 - **Auth**: `ANTHROPIC_API_KEY` environment variable (automatic).
 - **Non-interactive mode**: `claude -p "<prompt>"`
 - **Useful flags**: `--output-format json`, `--allowedTools "Read,Write,Bash(...)"`, `--append-system-prompt`
 ### Oz secret
 ```sh
 {{warp_cli_binary_name}} secret create ANTHROPIC_API_KEY --team --value-file key.txt --description "Anthropic API key for Claude Code"
 ```
 ### Example prompt
 ```
 Run: claude -p "Analyze the codebase and list potential security issues" --output-format json
 ```
 ### Artifact reporting prompt
 ```
 Run Claude Code to implement the feature:
  claude -p "Create a branch, implement the login fix, commit, push, and create a PR using gh CLI. Print the full PR URL and branch name at the end."
 After Claude Code finishes, find the PR URL and branch name from its output.
 Then call the report_pr tool with those values so the PR appears as an artifact.
 ```
 ---
 ## Codex CLI
 - **Package**: `npm install -g @openai/codex`
 - **Auth**: Requires an explicit login step before use:
  ```
  printenv OPENAI_API_KEY | codex login --with-api-key
  ```
  Alternatively, `CODEX_API_KEY` can be set directly.
 - **Recommended**: Add `printenv OPENAI_API_KEY | codex login --with-api-key` as an environment setup command so authentication happens automatically before the agent starts.
 - **Non-interactive mode**: `codex exec "<prompt>"`
 - **Regional endpoint**: Set `OPENAI_BASE_URL` if needed (e.g. `https://us.api.openai.com/v1`).
 - **Useful flags**: `--full-auto`, `--sandbox workspace-write`, `--json`, `--skip-git-repo-check`
 ### Oz secret
 ```sh
 {{warp_cli_binary_name}} secret create OPENAI_API_KEY --team --value-file key.txt --description "OpenAI API key for Codex CLI"
 ```
 ### Example prompt
 ```
 First authenticate Codex: printenv OPENAI_API_KEY | codex login --with-api-key
 Then run: codex exec "Refactor the utils module to reduce duplication"
 ```
 ### Artifact reporting prompt
 ```
 Authenticate Codex: printenv OPENAI_API_KEY | codex login --with-api-key
 Then run: codex exec --full-auto "Create a branch, fix the bug, commit, push, and create a PR. Print the PR URL and branch name."
 After Codex finishes, parse the PR URL and branch name from its output and call report_pr.
 ```
 ---
 ## Gemini CLI
 - **Package**: `npm install -g @google/gemini-cli`
 - **Auth**: `GEMINI_API_KEY` environment variable (automatic). Obtain from [Google AI Studio](https://aistudio.google.com/apikey).
 - **Non-interactive mode**: `gemini -p "<prompt>"` (headless mode)
 - **Useful flags**: `--output-format json`, `--yolo` (auto-approve tool actions)
 ### Oz secret
 ```sh
 {{warp_cli_binary_name}} secret create GEMINI_API_KEY --team --value-file key.txt --description "Gemini API key for Gemini CLI"
 ```
 ### Example prompt
 ```
 Run: gemini -p "Review the test suite and suggest missing edge cases" --output-format json
 ```
 ### Artifact reporting prompt
 ```
 Run Gemini CLI:
  gemini -p "Create a branch, implement the change, commit, push, and create a PR using gh CLI. Print the full PR URL and branch name at the end." --yolo
 After it finishes, parse the PR URL and branch from the output and call report_pr.
 ```
 ---
 ## Amp
 - **Package**: `npm install -g @sourcegraph/amp`
 - **Auth**: `AMP_API_KEY` environment variable. Obtain from [ampcode.com/settings](https://ampcode.com/settings). In isolated mode, uses `ANTHROPIC_API_KEY` instead.
 - **Non-interactive mode**: `amp -x "<prompt>"` (execute mode)
 - **Useful flags**: `--dangerously-allow-all` (skip tool approval prompts)
 ### Oz secret
 ```sh
 {{warp_cli_binary_name}} secret create AMP_API_KEY --team --value-file key.txt --description "Amp API key"
 ```
 ### Example prompt
 ```
 Run: amp -x "List all TODO comments in the codebase and group them by priority"
 ```
 ### Artifact reporting prompt
 ```
 Run Amp:
  amp --dangerously-allow-all -x "Create a branch, implement the fix, commit, push, and create a PR using gh CLI. Print the full PR URL and branch name."
 After Amp finishes, parse the PR URL and branch from the output and call report_pr.
 ```
 ---
 ## Copilot CLI
 - **Binary**: `copilot` (standalone, from [github/copilot-cli](https://github.com/github/copilot-cli))
 - **Auth**: `GH_TOKEN` or `GITHUB_TOKEN` environment variable with a fine-grained PAT that has the **Copilot Requests** permission. Also supports `COPILOT_GITHUB_TOKEN`.
 - **Non-interactive mode**: `copilot -p "<prompt>"`
 - **Useful flags**: `--allow-all-tools`
 - **Note**: The `gh copilot` extension (distinct from standalone `copilot`) requires OAuth and does **not** work with PATs.
 - **Not preinstalled** in Oz images. Install via setup commands or GitHub releases.
 ### Oz secret
 ```sh
 {{warp_cli_binary_name}} secret create GH_TOKEN --team --value-file token.txt --description "GitHub PAT with Copilot Requests permission"
 ```
 ### Example prompt
 ```
 Run: copilot -p "Review the latest changes and suggest improvements" --allow-all-tools
 ```
 ### Artifact reporting prompt
 ```
 Run Copilot CLI:
  copilot -p "Create a branch, implement the fix, commit, push, and create a PR using gh CLI. Print the full PR URL and branch name at the end." --allow-all-tools
 After Copilot finishes, parse the PR URL and branch from the output and call report_pr.
 ```
 ---
 ## OpenCode
 - **Install**: `curl -fsSL https://opencode.ai/install | bash` (or via binary release)
 - **Auth**: Uses provider-specific API keys via environment variables (e.g. `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`). Also reads from `.env` files. Run `opencode auth login` to configure interactively.
 - **Non-interactive mode**: `opencode run "<prompt>"` or `opencode -p "<prompt>"`
 - **Useful flags**: `-f json` (JSON output), `-q` (quiet/no spinner)
 - **Not preinstalled** in Oz images. Install via setup commands.
 ### Example prompt
 ```
 Run: opencode run "Explain the architecture of this project" -q
 ```
 ---
 ## Droid (Factory)
 - **Install**: `curl -fsSL https://app.factory.ai/cli | sh`
 - **Auth**: Requires a Factory account. Use `/login` in the CLI or generate an API key from Factory Settings. **Headless env-var auth is not yet confirmed** — this CLI may require interactive login.
 - **Non-interactive mode**: `droid exec "<prompt>"`
 - **Useful flags**: `--auto low|medium|high` (permission tier), `--skip-permissions-unsafe`
 - **Status**: **Not currently supported** for headless Oz environments due to unclear non-interactive auth. Excluded from prebuilt images.
 ---
 ## Quick Reference
 | CLI | Command | Auth Env Var | Non-Interactive Flag | Preinstalled |
 |-----|---------|-------------|---------------------|-------------|
 | Claude Code | `claude` | `ANTHROPIC_API_KEY` | `-p` | Yes |
 | Codex | `codex` | `OPENAI_API_KEY` | `exec` | Yes |
 | Gemini CLI | `gemini` | `GEMINI_API_KEY` | `-p` | Yes |
 | Amp | `amp` | `AMP_API_KEY` | `-x` | No |
 | Copilot CLI | `copilot` | `GH_TOKEN` / `GITHUB_TOKEN` | `-p` | No |
 | OpenCode | `opencode` | Provider-specific | `run` / `-p` | No |
 | Droid | `droid` | N/A (interactive login) | `exec` | No |