@dgxo/mashadevcli 1.1.0

package/bundle/docs/cli/tutorials/task-planning.md

@@ -0,0 +1,93 @@
+# Plan tasks with todos
+
+Keep complex jobs on the rails with Gemini CLI's built-in task planning. In this
+guide, you'll learn how to ask for a plan, execute it step-by-step, and monitor
+progress with the todo list.
+
+## Prerequisites
+
+- Gemini CLI installed and authenticated.
+- A complex task in mind (e.g., a multi-file refactor or new feature).
+
+## Why use task planning?
+
+Standard LLMs have a limited context window and can "forget" the original goal
+after 10 turns of code generation. Task planning provides:
+
+1.  **Visibility:** You see exactly what the agent plans to do _before_ it
+    starts.
+2.  **Focus:** The agent knows exactly which step it's working on right now.
+3.  **Resilience:** If the agent gets stuck, the plan helps it get back on
+    track.
+
+## How to ask for a plan
+
+The best way to trigger task planning is to explicitly ask for it.
+
+**Prompt:**
+`I want to migrate this project from JavaScript to TypeScript. Please make a plan first.`
+
+Gemini will analyze your codebase and use the `write_todos` tool to generate a
+structured list.
+
+**Example Plan:**
+
+1.  [ ] Create `tsconfig.json`.
+2.  [ ] Rename `.js` files to `.ts`.
+3.  [ ] Fix type errors in `utils.js`.
+4.  [ ] Fix type errors in `server.js`.
+5.  [ ] Verify build passes.
+
+## How to review and iterate
+
+Once the plan is generated, it appears in your CLI. Review it.
+
+- **Missing steps?** Tell the agent: "You forgot to add a step for installing
+  `@types/node`."
+- **Wrong order?** Tell the agent: "Let's verify the build _after_ each file,
+  not just at the end."
+
+The agent will update the todo list dynamically.
+
+## How to execute the plan
+
+Tell the agent to proceed.
+
+**Prompt:** `Looks good. Start with the first step.`
+
+As the agent works, you'll see the todo list update in real-time above the input
+box.
+
+- **Current focus:** The active task is highlighted (e.g.,
+  `[IN_PROGRESS] Create tsconfig.json`).
+- **Progress:** Completed tasks are marked as done.
+
+## How to monitor progress (`Ctrl+T`)
+
+For a long-running task, the full todo list might be hidden to save space. You
+can toggle the full view at any time.
+
+**Action:** Press **Ctrl+T**.
+
+This shows the complete list, including pending, in-progress, and completed
+items. It's a great way to check "how much is left?" without scrolling back up.
+
+## How to handle unexpected changes
+
+Plans change. Maybe you discover a library is incompatible halfway through.
+
+**Prompt:**
+`Actually, let's skip the 'server.js' refactor for now. It's too risky.`
+
+The agent will mark that task as `cancelled` or remove it, and move to the next
+item. This dynamic adjustment is what makes the todo system powerful—it's a
+living document, not a static text block.
+
+## Next steps
+
+- Explore [Session management](session-management.md) to save your plan and
+  finish it tomorrow.
+- See the [Todo tool reference](../../tools/todos.md) for technical schema
+  details.
+- Learn about [Memory management](memory-management.md) to persist planning
+  preferences (e.g., "Always create a test plan first").

package/bundle/docs/cli/tutorials/web-tools.md

@@ -0,0 +1,78 @@
+# Web search and fetch
+
+Access the live internet directly from your prompt. In this guide, you'll learn
+how to search for up-to-date documentation, fetch deep context from specific
+URLs, and apply that knowledge to your code.
+
+## Prerequisites
+
+- Gemini CLI installed and authenticated.
+- An internet connection.
+
+## How to research new technologies
+
+Imagine you want to use a library released yesterday. The model doesn't know
+about it yet. You need to teach it.
+
+### Scenario: Find documentation
+
+**Prompt:**
+`Search for the 'Bun 1.0' release notes and summarize the key changes.`
+
+Gemini uses the `google_web_search` tool to find relevant pages and synthesizes
+an answer. This "grounding" process ensures the agent isn't hallucinating
+features that don't exist.
+
+**Prompt:** `Find the documentation for the 'React Router v7' loader API.`
+
+## How to fetch deep context
+
+Search gives you a summary, but sometimes you need the raw details. The
+`web_fetch` tool lets you feed a specific URL directly into the agent's context.
+
+### Scenario: Reading a blog post
+
+You found a blog post with the exact solution to your bug.
+
+**Prompt:**
+`Read https://example.com/fixing-memory-leaks and explain how to apply it to my code.`
+
+Gemini will retrieve the page content (stripping away ads and navigation) and
+use it to answer your question.
+
+### Scenario: Comparing sources
+
+You can even fetch multiple pages to compare approaches.
+
+**Prompt:**
+`Compare the pagination patterns in https://api.example.com/v1/docs and https://api.example.com/v2/docs.`
+
+## How to apply knowledge to code
+
+The real power comes when you combine web tools with file editing.
+
+**Workflow:**
+
+1.  **Search:** "How do I implement auth with Supabase?"
+2.  **Fetch:** "Read this guide: https://supabase.com/docs/guides/auth."
+3.  **Implement:** "Great. Now use that pattern to create an `auth.ts` file in
+    my project."
+
+## How to troubleshoot errors
+
+When you hit an obscure error message, paste it into the chat.
+
+**Prompt:**
+`I'm getting 'Error: hydration mismatch' in Next.js. Search for recent solutions.`
+
+The agent will search sources such as GitHub issues, StackOverflow, and forums
+to find relevant fixes that might be too new to be in its base training set.
+
+## Next steps
+
+- Explore [File management](file-management.md) to see how to apply the code you
+  generate.
+- See the [Web search tool reference](../../tools/web-search.md) for citation
+  details.
+- See the [Web fetch tool reference](../../tools/web-fetch.md) for technical
+  limitations.

package/bundle/docs/core/index.md

@@ -0,0 +1,107 @@
+# Gemini CLI core
+
+Gemini CLI's core package (`packages/core`) is the backend portion of Gemini
+CLI, handling communication with the Gemini API, managing tools, and processing
+requests sent from `packages/cli`. For a general overview of Gemini CLI, see the
+[main documentation page](../index.md).
+
+## Navigating this section
+
+- **[Sub-agents (experimental)](./subagents.md):** Learn how to create and use
+  specialized sub-agents for complex tasks.
+- **[Core tools reference](../reference/tools.md):** Information on how tools
+  are defined, registered, and used by the core.
+- **[Memory Import Processor](../reference/memport.md):** Documentation for the
+  modular GEMINI.md import feature using @file.md syntax.
+- **[Policy Engine](../reference/policy-engine.md):** Use the Policy Engine for
+  fine-grained control over tool execution.
+
+## Role of the core
+
+While the `packages/cli` portion of Gemini CLI provides the user interface,
+`packages/core` is responsible for:
+
+- **Gemini API interaction:** Securely communicating with the Google Gemini API,
+  sending user prompts, and receiving model responses.
+- **Prompt engineering:** Constructing effective prompts for the Gemini model,
+  potentially incorporating conversation history, tool definitions, and
+  instructional context from `GEMINI.md` files.
+- **Tool management & orchestration:**
+  - Registering available tools (e.g., file system tools, shell command
+    execution).
+  - Interpreting tool use requests from the Gemini model.
+  - Executing the requested tools with the provided arguments.
+  - Returning tool execution results to the Gemini model for further processing.
+- **Session and state management:** Keeping track of the conversation state,
+  including history and any relevant context required for coherent interactions.
+- **Configuration:** Managing core-specific configurations, such as API key
+  access, model selection, and tool settings.
+
+## Security considerations
+
+The core plays a vital role in security:
+
+- **API key management:** It handles the `GEMINI_API_KEY` and ensures it's used
+  securely when communicating with the Gemini API.
+- **Tool execution:** When tools interact with the local system (e.g.,
+  `run_shell_command`), the core (and its underlying tool implementations) must
+  do so with appropriate caution, often involving sandboxing mechanisms to
+  prevent unintended modifications.
+
+## Chat history compression
+
+To ensure that long conversations don't exceed the token limits of the Gemini
+model, the core includes a chat history compression feature.
+
+When a conversation approaches the token limit for the configured model, the
+core automatically compresses the conversation history before sending it to the
+model. This compression is designed to be lossless in terms of the information
+conveyed, but it reduces the overall number of tokens used.
+
+You can find the token limits for each model in the
+[Google AI documentation](https://ai.google.dev/gemini-api/docs/models).
+
+## Model fallback
+
+Gemini CLI includes a model fallback mechanism to ensure that you can continue
+to use the CLI even if the default "pro" model is rate-limited.
+
+If you are using the default "pro" model and the CLI detects that you are being
+rate-limited, it automatically switches to the "flash" model for the current
+session. This allows you to continue working without interruption.
+
+Internal utility calls that use `gemini-2.5-flash-lite` (for example, prompt
+completion and classification) silently fall back to `gemini-2.5-flash` and
+`gemini-2.5-pro` when quota is exhausted, without changing the configured model.
+
+## File discovery service
+
+The file discovery service is responsible for finding files in the project that
+are relevant to the current context. It is used by the `@` command and other
+tools that need to access files.
+
+## Memory discovery service
+
+The memory discovery service is responsible for finding and loading the
+`GEMINI.md` files that provide context to the model. It searches for these files
+in a hierarchical manner, starting from the current working directory and moving
+up to the project root and the user's home directory. It also searches in
+subdirectories.
+
+This allows you to have global, project-level, and component-level context
+files, which are all combined to provide the model with the most relevant
+information.
+
+You can use the [`/memory` command](../reference/commands.md) to `show`, `add`,
+and `refresh` the content of loaded `GEMINI.md` files.
+
+## Citations
+
+When Gemini finds it is reciting text from a source it appends the citation to
+the output. It is enabled by default but can be disabled with the
+ui.showCitations setting.
+
+- When proposing an edit the citations display before giving the user the option
+  to accept.
+- Citations are always shown at the end of the model’s turn.
+- We deduplicate citations and display them in alphabetical order.

package/bundle/docs/core/remote-agents.md

@@ -0,0 +1,84 @@
+# Remote Subagents (experimental)
+
+Gemini CLI supports connecting to remote subagents using the Agent-to-Agent
+(A2A) protocol. This allows Gemini CLI to interact with other agents, expanding
+its capabilities by delegating tasks to remote services.
+
+Gemini CLI can connect to any compliant A2A agent. You can find samples of A2A
+agents in the following repositories:
+
+- [ADK Samples (Python)](https://github.com/google/adk-samples/tree/main/python)
+- [ADK Python Contributing Samples](https://github.com/google/adk-python/tree/main/contributing/samples)
+
+> **Note: Remote subagents are currently an experimental feature.**
+
+## Configuration
+
+To use remote subagents, you must explicitly enable them in your
+`settings.json`:
+
+```json
+{
+  "experimental": {
+    "enableAgents": true
+  }
+}
+```
+
+## Defining remote subagents
+
+Remote subagents are defined as Markdown files (`.md`) with YAML frontmatter.
+You can place them in:
+
+1.  **Project-level:** `.gemini/agents/*.md` (Shared with your team)
+2.  **User-level:** `~/.gemini/agents/*.md` (Personal agents)
+
+### Configuration schema
+
+| Field            | Type   | Required | Description                                                                                                    |
+| :--------------- | :----- | :------- | :------------------------------------------------------------------------------------------------------------- |
+| `kind`           | string | Yes      | Must be `remote`.                                                                                              |
+| `name`           | string | Yes      | A unique name for the agent. Must be a valid slug (lowercase letters, numbers, hyphens, and underscores only). |
+| `agent_card_url` | string | Yes      | The URL to the agent's A2A card endpoint.                                                                      |
+
+### Single-subagent example
+
+```markdown
+---
+kind: remote
+name: my-remote-agent
+agent_card_url: https://example.com/agent-card
+---
+```
+
+### Multi-subagent example
+
+The loader explicitly supports multiple remote subagents defined in a single
+Markdown file.
+
+```markdown
+---
+- kind: remote
+  name: remote-1
+  agent_card_url: https://example.com/1
+- kind: remote
+  name: remote-2
+  agent_card_url: https://example.com/2
+---
+```
+
+> **Note:** Mixed local and remote agents, or multiple local agents, are not
+> supported in a single file; the list format is currently remote-only.
+
+## Managing Subagents
+
+Users can manage subagents using the following commands within the Gemini CLI:
+
+- `/agents list`: Displays all available local and remote subagents.
+- `/agents refresh`: Reloads the agent registry. Use this after adding or
+  modifying agent definition files.
+- `/agents enable <agent_name>`: Enables a specific subagent.
+- `/agents disable <agent_name>`: Disables a specific subagent.
+
+> **Tip:** You can use the `@cli_help` agent within Gemini CLI for assistance
+> with configuring subagents.

package/bundle/docs/core/subagents.md

@@ -0,0 +1,307 @@
+# Subagents (experimental)
+
+Subagents are specialized agents that operate within your main Gemini CLI
+session. They are designed to handle specific, complex tasks—like deep codebase
+analysis, documentation lookup, or domain-specific reasoning—without cluttering
+the main agent's context or toolset.
+
+> **Note: Subagents are currently an experimental feature.**
+>
+> To use custom subagents, you must explicitly enable them in your
+> `settings.json`:
+>
+> ```json
+> {
+>   "experimental": { "enableAgents": true }
+> }
+> ```
+>
+> **Warning:** Subagents currently operate in
+> ["YOLO mode"](../reference/configuration.md#command-line-arguments), meaning
+> they may execute tools without individual user confirmation for each step.
+> Proceed with caution when defining agents with powerful tools like
+> `run_shell_command` or `write_file`.
+
+## What are subagents?
+
+Subagents are "specialists" that the main Gemini agent can hire for a specific
+job.
+
+- **Focused context:** Each subagent has its own system prompt and persona.
+- **Specialized tools:** Subagents can have a restricted or specialized set of
+  tools.
+- **Independent context window:** Interactions with a subagent happen in a
+  separate context loop, which saves tokens in your main conversation history.
+
+Subagents are exposed to the main agent as a tool of the same name. When the
+main agent calls the tool, it delegates the task to the subagent. Once the
+subagent completes its task, it reports back to the main agent with its
+findings.
+
+## Built-in subagents
+
+Gemini CLI comes with the following built-in subagents:
+
+### Codebase Investigator
+
+- **Name:** `codebase_investigator`
+- **Purpose:** Analyze the codebase, reverse engineer, and understand complex
+  dependencies.
+- **When to use:** "How does the authentication system work?", "Map out the
+  dependencies of the `AgentRegistry` class."
+- **Configuration:** Enabled by default. You can configure it in
+  `settings.json`. Example (forcing a specific model):
+  ```json
+  {
+    "experimental": {
+      "codebaseInvestigatorSettings": {
+        "enabled": true,
+        "maxNumTurns": 20,
+        "model": "gemini-2.5-pro"
+      }
+    }
+  }
+  ```
+
+### CLI Help Agent
+
+- **Name:** `cli_help`
+- **Purpose:** Get expert knowledge about Gemini CLI itself, its commands,
+  configuration, and documentation.
+- **When to use:** "How do I configure a proxy?", "What does the `/rewind`
+  command do?"
+- **Configuration:** Enabled by default.
+
+### Generalist Agent
+
+- **Name:** `generalist_agent`
+- **Purpose:** Route tasks to the appropriate specialized subagent.
+- **When to use:** Implicitly used by the main agent for routing. Not directly
+  invoked by the user.
+- **Configuration:** Enabled by default. No specific configuration options.
+
+### Browser Agent (experimental)
+
+- **Name:** `browser_agent`
+- **Purpose:** Automate web browser tasks — navigating websites, filling forms,
+  clicking buttons, and extracting information from web pages — using the
+  accessibility tree.
+- **When to use:** "Go to example.com and fill out the contact form," "Extract
+  the pricing table from this page," "Click the login button and enter my
+  credentials."
+
+> **Note:** This is a preview feature currently under active development.
+
+#### Prerequisites
+
+The browser agent requires:
+
+- **Chrome** version 144 or later (any recent stable release will work).
+- **Node.js** with `npx` available (used to launch the
+  [`chrome-devtools-mcp`](https://www.npmjs.com/package/chrome-devtools-mcp)
+  server).
+
+#### Enabling the browser agent
+
+The browser agent is disabled by default. Enable it in your `settings.json`:
+
+```json
+{
+  "agents": {
+    "overrides": {
+      "browser_agent": {
+        "enabled": true
+      }
+    }
+  }
+}
+```
+
+#### Session modes
+
+The `sessionMode` setting controls how Chrome is launched and managed. Set it
+under `agents.browser`:
+
+```json
+{
+  "agents": {
+    "overrides": {
+      "browser_agent": {
+        "enabled": true
+      }
+    },
+    "browser": {
+      "sessionMode": "persistent"
+    }
+  }
+}
+```
+
+The available modes are:
+
+| Mode         | Description                                                                                                                                                                                 |
+| :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `persistent` | **(Default)** Launches Chrome with a persistent profile stored at `~/.gemini/cli-browser-profile/`. Cookies, history, and settings are preserved between sessions.                          |
+| `isolated`   | Launches Chrome with a temporary profile that is deleted after each session. Use this for clean-state automation.                                                                           |
+| `existing`   | Attaches to an already-running Chrome instance. You must enable remote debugging first by navigating to `chrome://inspect/#remote-debugging` in Chrome. No new browser process is launched. |
+
+#### Configuration reference
+
+All browser-specific settings go under `agents.browser` in your `settings.json`.
+
+| Setting       | Type      | Default        | Description                                                                                     |
+| :------------ | :-------- | :------------- | :---------------------------------------------------------------------------------------------- |
+| `sessionMode` | `string`  | `"persistent"` | How Chrome is managed: `"persistent"`, `"isolated"`, or `"existing"`.                           |
+| `headless`    | `boolean` | `false`        | Run Chrome in headless mode (no visible window).                                                |
+| `profilePath` | `string`  | —              | Custom path to a browser profile directory.                                                     |
+| `visualModel` | `string`  | —              | Model override for the visual agent (for example, `"gemini-2.5-computer-use-preview-10-2025"`). |
+
+#### Security
+
+The browser agent enforces the following security restrictions:
+
+- **Blocked URL patterns:** `file://`, `javascript:`, `data:text/html`,
+  `chrome://extensions`, and `chrome://settings/passwords` are always blocked.
+- **Sensitive action confirmation:** Actions like form filling, file uploads,
+  and form submissions require user confirmation through the standard policy
+  engine.
+
+#### Visual agent
+
+By default, the browser agent interacts with pages through the accessibility
+tree using element `uid` values. For tasks that require visual identification
+(for example, "click the yellow button" or "find the red error message"), you
+can enable the visual agent by setting a `visualModel`:
+
+```json
+{
+  "agents": {
+    "overrides": {
+      "browser_agent": {
+        "enabled": true
+      }
+    },
+    "browser": {
+      "visualModel": "gemini-2.5-computer-use-preview-10-2025"
+    }
+  }
+}
+```
+
+When enabled, the agent gains access to the `analyze_screenshot` tool, which
+captures a screenshot and sends it to the vision model for analysis. The model
+returns coordinates and element descriptions that the browser agent uses with
+the `click_at` tool for precise, coordinate-based interactions.
+
+> **Note:** The visual agent requires API key or Vertex AI authentication. It is
+> not available when using Google Login.
+
+## Creating custom subagents
+
+You can create your own subagents to automate specific workflows or enforce
+specific personas. To use custom subagents, you must enable them in your
+`settings.json`:
+
+```json
+{
+  "experimental": {
+    "enableAgents": true
+  }
+}
+```
+
+### Agent definition files
+
+Custom agents are defined as Markdown files (`.md`) with YAML frontmatter. You
+can place them in:
+
+1.  **Project-level:** `.gemini/agents/*.md` (Shared with your team)
+2.  **User-level:** `~/.gemini/agents/*.md` (Personal agents)
+
+### File format
+
+The file **MUST** start with YAML frontmatter enclosed in triple-dashes `---`.
+The body of the markdown file becomes the agent's **System Prompt**.
+
+**Example: `.gemini/agents/security-auditor.md`**
+
+```markdown
+---
+name: security-auditor
+description: Specialized in finding security vulnerabilities in code.
+kind: local
+tools:
+  - read_file
+  - grep_search
+model: gemini-2.5-pro
+temperature: 0.2
+max_turns: 10
+---
+
+You are a ruthless Security Auditor. Your job is to analyze code for potential
+vulnerabilities.
+
+Focus on:
+
+1.  SQL Injection
+2.  XSS (Cross-Site Scripting)
+3.  Hardcoded credentials
+4.  Unsafe file operations
+
+When you find a vulnerability, explain it clearly and suggest a fix. Do not fix
+it yourself; just report it.
+```
+
+### Configuration schema
+
+| Field          | Type   | Required | Description                                                                                                               |
+| :------------- | :----- | :------- | :------------------------------------------------------------------------------------------------------------------------ |
+| `name`         | string | Yes      | Unique identifier (slug) used as the tool name for the agent. Only lowercase letters, numbers, hyphens, and underscores.  |
+| `description`  | string | Yes      | Short description of what the agent does. This is visible to the main agent to help it decide when to call this subagent. |
+| `kind`         | string | No       | `local` (default) or `remote`.                                                                                            |
+| `tools`        | array  | No       | List of tool names this agent can use. If omitted, it may have access to a default set.                                   |
+| `model`        | string | No       | Specific model to use (e.g., `gemini-2.5-pro`). Defaults to `inherit` (uses the main session model).                      |
+| `temperature`  | number | No       | Model temperature (0.0 - 2.0).                                                                                            |
+| `max_turns`    | number | No       | Maximum number of conversation turns allowed for this agent before it must return. Defaults to `15`.                      |
+| `timeout_mins` | number | No       | Maximum execution time in minutes. Defaults to `5`.                                                                       |
+
+### Optimizing your subagent
+
+The main agent's system prompt encourages it to use an expert subagent when one
+is available. It decides whether an agent is a relevant expert based on the
+agent's description. You can improve the reliability with which an agent is used
+by updating the description to more clearly indicate:
+
+- Its area of expertise.
+- When it should be used.
+- Some example scenarios.
+
+For example, the following subagent description should be called fairly
+consistently for Git operations.
+
+> Git expert agent which should be used for all local and remote git operations.
+> For example:
+>
+> - Making commits
+> - Searching for regressions with bisect
+> - Interacting with source control and issues providers such as GitHub.
+
+If you need to further tune your subagent, you can do so by selecting the model
+to optimize for with `/model` and then asking the model why it does not think
+that your subagent was called with a specific prompt and the given description.
+
+## Remote subagents (Agent2Agent) (experimental)
+
+Gemini CLI can also delegate tasks to remote subagents using the Agent-to-Agent
+(A2A) protocol.
+
+> **Note: Remote subagents are currently an experimental feature.**
+
+See the [Remote Subagents documentation](/docs/core/remote-agents) for detailed
+configuration and usage instructions.
+
+## Extension subagents
+
+Extensions can bundle and distribute subagents. See the
+[Extensions documentation](../extensions/index.md#subagents) for details on how
+to package agents within an extension.