zrb 1.15.3__py3-none-any.whl → 1.21.29__py3-none-any.whl

zrb/builtin/searxng/start.py

@@ -0,0 +1,21 @@
+import os
+
+from zrb.builtin.group import searxng_group
+from zrb.config.config import CFG
+from zrb.input.int_input import IntInput
+from zrb.task.cmd_task import CmdTask
+from zrb.task.http_check import HttpCheck
+
+start_searxng = searxng_group.add_task(
+    CmdTask(
+        name="start-searxng",
+        input=IntInput(name="port", default=CFG.SEARXNG_PORT),
+        cwd=os.path.dirname(__file__),
+        cmd="docker run --rm -p {ctx.input.port}:8080 -v ./config/:/etc/searxng/ docker.io/searxng/searxng:latest -d",  # noqa
+        readiness_check=HttpCheck(
+            "check-searxng",
+            url="http://localhost:{ctx.input.port}",
+        ),
+    ),
+    alias="start",
+)

zrb/builtin/shell/autocomplete/bash.py

@@ -1,5 +1,6 @@
 from zrb.builtin.group import shell_autocomplete_group
-from zrb.context.context import Context
+from zrb.config.config import CFG
+from zrb.context.context import AnyContext
 from zrb.task.make_task import make_task
 
 _COMPLETION_SCRIPT = """
@@ -36,5 +37,5 @@ complete -F _zrb_complete zrb
     group=shell_autocomplete_group,
     alias="bash",
 )
-def make_bash_autocomplete(ctx: Context):
-    return _COMPLETION_SCRIPT
+def make_bash_autocomplete(ctx: AnyContext):
+    return _COMPLETION_SCRIPT.replace("zrb", CFG.ROOT_GROUP_NAME)

zrb/builtin/shell/autocomplete/zsh.py

@@ -1,5 +1,6 @@
 from zrb.builtin.group import shell_autocomplete_group
-from zrb.context.context import Context
+from zrb.config.config import CFG
+from zrb.context.context import AnyContext
 from zrb.task.make_task import make_task
 
 _COMPLETION_SCRIPT = """
@@ -33,5 +34,5 @@ compdef _zrb_complete zrb
     group=shell_autocomplete_group,
     alias="zsh",
 )
-def make_zsh_autocomplete(ctx: Context):
-    return _COMPLETION_SCRIPT
+def make_zsh_autocomplete(ctx: AnyContext):
+    return _COMPLETION_SCRIPT.replace("zrb", CFG.ROOT_GROUP_NAME)

zrb/config/config.py

@@ -28,8 +28,13 @@ class Config:
     def ENV_PREFIX(self) -> str:
         return os.getenv("_ZRB_ENV_PREFIX", "ZRB")
 
-    def _getenv(self, env_name: str, default: str = "") -> str:
-        return os.getenv(f"{self.ENV_PREFIX}_{env_name}", default)
+    def _getenv(self, env_name: str | list[str], default: str = "") -> str:
+        env_name_list = env_name if isinstance(env_name, list) else [env_name]
+        for env_name in env_name_list:
+            value = os.getenv(f"{self.ENV_PREFIX}_{env_name}", None)
+            if value is not None:
+                return value
+        return default
 
     def _get_internal_default_prompt(self, name: str) -> str:
         if name not in self.__internal_default_prompt:
@@ -60,6 +65,38 @@ class Config:
     def DEFAULT_EDITOR(self) -> str:
         return self._getenv("EDITOR", "nano")
 
+    @property
+    def DEFAULT_DIFF_EDIT_COMMAND_TPL(self) -> str:
+        return self._getenv("DIFF_EDIT_COMMAND", self._get_default_diff_edit_command())
+
+    def _get_default_diff_edit_command(self) -> str:
+        editor = self.DEFAULT_EDITOR
+        if editor in [
+            "code",
+            "vscode",
+            "vscodium",
+            "windsurf",
+            "cursor",
+            "zed",
+            "zeditor",
+            "agy",
+        ]:
+            return f"{editor} --wait --diff {{old}} {{new}}"
+        if editor == "emacs":
+            return 'emacs --eval \'(ediff-files "{old}" "{new}")\''
+        if editor in ["nvim", "vim"]:
+            return (
+                f"{editor} -d {{old}} {{new}} "
+                "-i NONE "
+                '-c "wincmd h | set readonly | wincmd l" '
+                '-c "highlight DiffAdd cterm=bold ctermbg=22 guibg=#005f00 | highlight DiffChange cterm=bold ctermbg=24 guibg=#005f87 | highlight DiffText ctermbg=21 guibg=#0000af | highlight DiffDelete ctermbg=52 guibg=#5f0000" '  # noqa
+                '-c "set showtabline=2 | set tabline=[Instructions]\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)" '  # noqa
+                '-c "wincmd h | setlocal statusline=OLD\\ FILE" '
+                '-c "wincmd l | setlocal statusline=%#StatusBold#NEW\\ FILE\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)" '  # noqa
+                '-c "autocmd BufWritePost * wqa"'
+            )
+        return 'vimdiff {old} {new} +"setlocal ro" +"wincmd l" +"autocmd BufWritePost <buffer> qa"'  # noqa
+
     @property
     def INIT_MODULES(self) -> list[str]:
         init_modules_str = self._getenv("INIT_MODULES", "")
@@ -102,6 +139,7 @@ class Config:
         level = level.upper()
         log_levels = {
             "CRITICAL": logging.CRITICAL,  # 50
+            "FATAL": logging.CRITICAL,  # 50
             "ERROR": logging.ERROR,  # 40
             "WARN": logging.WARNING,  # 30
             "WARNING": logging.WARNING,  # 30
@@ -243,6 +281,21 @@ class Config:
         value = self._getenv("LLM_API_KEY")
         return None if value == "" else value
 
+    @property
+    def LLM_MODEL_SMALL(self) -> str | None:
+        value = self._getenv("LLM_MODEL_SMALL")
+        return None if value == "" else value
+
+    @property
+    def LLM_BASE_URL_SMALL(self) -> str | None:
+        value = self._getenv("LLM_BASE_URL_SMALL")
+        return None if value == "" else value
+
+    @property
+    def LLM_API_KEY_SMALL(self) -> str | None:
+        value = self._getenv("LLM_API_KEY_SMALL")
+        return None if value == "" else value
+
     @property
     def LLM_SYSTEM_PROMPT(self) -> str | None:
         value = self._getenv("LLM_SYSTEM_PROMPT")
@@ -259,12 +312,28 @@ class Config:
         return None if value == "" else value
 
     @property
-    def LLM_MODES(self) -> list[str]:
-        return [
-            mode.strip()
-            for mode in self._getenv("LLM_MODES", "coding").split(",")
-            if mode.strip() != ""
-        ]
+    def LLM_WORKFLOWS(self) -> list[str]:
+        """Get a list of LLM workflows from environment variables."""
+        workflows = []
+        for workflow in self._getenv("LLM_WORKFLOWS", "").split(","):
+            workflow = workflow.strip()
+            if workflow != "":
+                workflows.append(workflow)
+        return workflows
+
+    @property
+    def LLM_BUILTIN_WORKFLOW_PATHS(self) -> list[str]:
+        """Get a list of additional builtin workflow paths from environment variables."""
+        builtin_workflow_paths_str = self._getenv(
+            ["LLM_BUILTIN_WORFKLOW_PATH", "LLM_BUILTIN_WORKFLOW_PATHS"], ""
+        )
+        if builtin_workflow_paths_str != "":
+            return [
+                path.strip()
+                for path in builtin_workflow_paths_str.split(":")
+                if path.strip() != ""
+            ]
+        return []
 
     @property
     def LLM_SPECIAL_INSTRUCTION_PROMPT(self) -> str | None:
@@ -276,13 +345,21 @@ class Config:
         value = self._getenv("LLM_SUMMARIZATION_PROMPT")
         return None if value == "" else value
 
+    @property
+    def LLM_SHOW_TOOL_CALL_RESULT(self) -> bool:
+        return to_boolean(self._getenv("LLM_SHOW_TOOL_CALL_RESULT", "false"))
+
     @property
     def LLM_MAX_REQUESTS_PER_MINUTE(self) -> int:
         """
         Maximum number of LLM requests allowed per minute.
         Default is conservative to accommodate free-tier LLM providers.
         """
-        return int(self._getenv("LLM_MAX_REQUESTS_PER_MINUTE", "15"))
+        return int(
+            self._getenv(
+                ["LLM_MAX_REQUEST_PER_MINUTE", "LLM_MAX_REQUESTS_PER_MINUTE"], "60"
+            )
+        )
 
     @property
     def LLM_MAX_TOKENS_PER_MINUTE(self) -> int:
@@ -290,21 +367,46 @@ class Config:
         Maximum number of LLM tokens allowed per minute.
         Default is conservative to accommodate free-tier LLM providers.
         """
-        return int(self._getenv("LLM_MAX_TOKENS_PER_MINUTE", "100000"))
+        return int(
+            self._getenv(
+                ["LLM_MAX_TOKEN_PER_MINUTE", "LLM_MAX_TOKENS_PER_MINUTE"], "100000"
+            )
+        )
 
     @property
     def LLM_MAX_TOKENS_PER_REQUEST(self) -> int:
         """Maximum number of tokens allowed per individual LLM request."""
-        return int(self._getenv("LLM_MAX_TOKENS_PER_REQUEST", "50000"))
+        return int(
+            self._getenv(
+                ["LLM_MAX_TOKEN_PER_REQUEST", "LLM_MAX_TOKENS_PER_REQUEST"], "120000"
+            )
+        )
+
+    @property
+    def LLM_MAX_TOKENS_PER_TOOL_CALL_RESULT(self) -> int:
+        """Maximum number of tokens allowed per tool call result."""
+        return int(
+            self._getenv(
+                [
+                    "LLM_MAX_TOKEN_PER_TOOL_CALL_RESULT",
+                    "LLM_MAX_TOKENS_PER_TOOL_CALL_RESULT",
+                ],
+                str(self._get_max_threshold(0.4)),
+            )
+        )
 
     @property
     def LLM_THROTTLE_SLEEP(self) -> float:
         """Number of seconds to sleep when throttling is required."""
-        return float(self._getenv("LLM_THROTTLE_SLEEP", "1.0"))
+        return float(self._getenv("LLM_THROTTLE_SLEEP", "5.0"))
 
     @property
-    def LLM_YOLO_MODE(self) -> bool:
-        return to_boolean(self._getenv("LLM_YOLO_MODE", "false"))
+    def LLM_YOLO_MODE(self) -> bool | list[str]:
+        str_val = self._getenv("LLM_YOLO_MODE", "false")
+        try:
+            return to_boolean(str_val)
+        except Exception:
+            return [val.strip() for val in str_val.split(",") if val.strip() != ""]
 
     @property
     def LLM_SUMMARIZE_HISTORY(self) -> bool:
@@ -312,19 +414,51 @@ class Config:
 
     @property
     def LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD(self) -> int:
-        return int(self._getenv("LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD", "20000"))
+        threshold = int(
+            self._getenv(
+                "LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD",
+                str(self._get_max_threshold(0.6)),
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.6)
 
     @property
     def LLM_REPO_ANALYSIS_EXTRACTION_TOKEN_THRESHOLD(self) -> int:
-        return int(self._getenv("LLM_REPO_ANALYSIS_EXTRACTION_TOKEN_LIMIT", "35000"))
+        threshold = int(
+            self._getenv(
+                "LLM_REPO_ANALYSIS_EXTRACTION_TOKEN_THRESHOLD",
+                str(self._get_max_threshold(0.4)),
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.4)
 
     @property
     def LLM_REPO_ANALYSIS_SUMMARIZATION_TOKEN_THRESHOLD(self) -> int:
-        return int(self._getenv("LLM_REPO_ANALYSIS_SUMMARIZATION_TOKEN_LIMIT", "35000"))
+        threshold = int(
+            self._getenv(
+                "LLM_REPO_ANALYSIS_SUMMARIZATION_TOKEN_THRESHOLD",
+                str(self._get_max_threshold(0.4)),
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.4)
 
     @property
-    def LLM_FILE_ANALYSIS_TOKEN_LIMIT(self) -> int:
-        return int(self._getenv("LLM_FILE_ANALYSIS_TOKEN_LIMIT", "35000"))
+    def LLM_FILE_ANALYSIS_TOKEN_THRESHOLD(self) -> int:
+        threshold = int(
+            self._getenv(
+                "LLM_FILE_ANALYSIS_TOKEN_THRESHOLD", str(self._get_max_threshold(0.4))
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.4)
+
+    def _limit_token_threshold(self, threshold: int, factor: float) -> int:
+        return min(threshold, self._get_max_threshold(factor))
+
+    def _get_max_threshold(self, factor: float) -> int:
+        return round(
+            factor
+            * min(self.LLM_MAX_TOKENS_PER_MINUTE, self.LLM_MAX_TOKENS_PER_REQUEST)
+        )
 
     @property
     def LLM_FILE_EXTRACTOR_SYSTEM_PROMPT(self) -> str:
@@ -378,14 +512,6 @@ class Config:
     def LLM_ALLOW_SEARCH_INTERNET(self) -> bool:
         return to_boolean(self._getenv("LLM_ALLOW_SEARCH_INTERNET", "1"))
 
-    @property
-    def LLM_ALLOW_SEARCH_ARXIV(self) -> bool:
-        return to_boolean(self._getenv("LLM_ALLOW_SEARCH_ARXIV", "1"))
-
-    @property
-    def LLM_ALLOW_SEARCH_WIKIPEDIA(self) -> bool:
-        return to_boolean(self._getenv("LLM_ALLOW_SEARCH_WIKIPEDIA", "1"))
-
     @property
     def LLM_ALLOW_GET_CURRENT_LOCATION(self) -> bool:
         return to_boolean(self._getenv("LLM_ALLOW_GET_CURRENT_LOCATION", "1"))
@@ -420,10 +546,51 @@ class Config:
     def RAG_MAX_RESULT_COUNT(self) -> int:
         return int(self._getenv("RAG_MAX_RESULT_COUNT", "5"))
 
+    @property
+    def SEARCH_INTERNET_METHOD(self) -> str:
+        """Either serpapi or searxng"""
+        return self._getenv("SEARCH_INTERNET_METHOD", "serpapi")
+
+    @property
+    def BRAVE_API_KEY(self) -> str:
+        return os.getenv("BRAVE_API_KEY", "")
+
+    @property
+    def BRAVE_API_SAFE(self) -> str:
+        return self._getenv("BRAVE_API_SAFE", "off")
+
+    @property
+    def BRAVE_API_LANG(self) -> str:
+        return self._getenv("BRAVE_API_LANG", "en")
+
     @property
     def SERPAPI_KEY(self) -> str:
         return os.getenv("SERPAPI_KEY", "")
 
+    @property
+    def SERPAPI_SAFE(self) -> str:
+        return self._getenv("SERPAPI_SAFE", "off")
+
+    @property
+    def SERPAPI_LANG(self) -> str:
+        return self._getenv("SERPAPI_LANG", "en")
+
+    @property
+    def SEARXNG_PORT(self) -> int:
+        return int(self._getenv("SEARXNG_PORT", "8080"))
+
+    @property
+    def SEARXNG_BASE_URL(self) -> str:
+        return self._getenv("SEARXNG_BASE_URL", f"http://localhost:{self.SEARXNG_PORT}")
+
+    @property
+    def SEARXNG_SAFE(self) -> int:
+        return int(self._getenv("SEARXNG_SAFE", "0"))
+
+    @property
+    def SEARXNG_LANG(self) -> str:
+        return self._getenv("SEARXNG_LANG", "en")
+
     @property
     def BANNER(self) -> str:
         return fstring_format(
@@ -435,5 +602,13 @@ class Config:
     def LLM_CONTEXT_FILE(self) -> str:
         return self._getenv("LLM_CONTEXT_FILE", "ZRB.md")
 
+    @property
+    def USE_TIKTOKEN(self) -> bool:
+        return to_boolean(self._getenv("USE_TIKTOKEN", "true"))
+
+    @property
+    def TIKTOKEN_ENCODING_NAME(self) -> str:
+        return self._getenv("TIKTOKEN_ENCODING_NAME", "cl100k_base")
+
 
 CFG = Config()

zrb/config/default_prompt/file_extractor_system_prompt.md

@@ -1,12 +1,112 @@
-You are an intelligent code and configuration analysis agent.
-Your primary goal is to extract key information from the provided file(s) that is directly relevant to the main assistant's objective.
+You are an expert code and configuration analysis agent. Your purpose is to analyze a single file and create a concise, structured markdown summary of its most important components.
 
-Analyze the file content and determine its type (e.g., Python script, YAML configuration, Dockerfile, Markdown documentation).
-Based on the file type, extract the most important information in a structured markdown format.
+### Instructions
 
-- For source code (e.g., .py, .js, .go): Extract key components like classes, functions, important variables, and their purposes.
-- For configuration files (e.g., .yaml, .toml, .json): Extract the main configuration sections, keys, and their values.
-- For infrastructure files (e.g., Dockerfile, .tf): Extract resources, settings, and commands.
-- For documentation (e.g., .md): Extract headings, summaries, code blocks, and links.
+1. **Analyze File Content**: Determine the file's type (e.g., Python, Dockerfile, YAML, Markdown).
+2. **Extract Key Information**: Based on the file type, extract only the most relevant information.
+   * **Source Code** (`.py`, `.js`, `.go`): Extract classes, functions, key variables, and their purpose.
+   * **Configuration** (`.yaml`, `.toml`, `.json`): Extract main sections, keys, and values.
+   * **Infrastructure** (`Dockerfile`, `.tf`): Extract resources, settings, and commands.
+   * **Documentation** (`.md`): Extract headings, summaries, and code blocks.
+3. **Format Output**: Present the summary in structured markdown.
 
-Focus on quality and relevance over quantity. The output should be a concise yet comprehensive summary that directly helps the main assistant achieve its goal.
+### Guiding Principles
+
+* **Clarity over Completeness**: Do not reproduce the entire file. Capture its essence.
+* **Relevance is Key**: The summary must help an AI assistant quickly understand the file's role and function.
+* **Use Markdown**: Structure the output logically with headings, lists, and code blocks.
+
+---
+
+### Examples
+
+Here are examples of the expected output.
+
+#### Example 1: Python Source File (`database.py`)
+
+**Input File:**
+```python
+# src/database.py
+import os
+from sqlalchemy import create_engine, Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./test.db")
+
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+```
+
+**Expected Markdown Output:**
+```markdown
+### File Summary: `src/database.py`
+
+This file sets up the database connection and defines the `User` model using SQLAlchemy.
+
+**Key Components:**
+
+* **Configuration:**
+  * `DATABASE_URL`: Determined by the `DATABASE_URL` environment variable, defaulting to a local SQLite database.
+* **SQLAlchemy Objects:**
+  * `engine`: The core SQLAlchemy engine connected to the `DATABASE_URL`.
+  * `SessionLocal`: A factory for creating new database sessions.
+  * `Base`: The declarative base for ORM models.
+* **ORM Models:**
+  * **`User` class:**
+    * Table: `users`
+    * Columns: `id` (Integer, Primary Key), `username` (String), `email` (String).
+* **Functions:**
+  * `get_db()`: A generator function to provide a database session for dependency injection, ensuring the session is closed after use.
+```
+
+#### Example 2: Infrastructure File (`Dockerfile`)
+
+**Input File:**
+```dockerfile
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]
+```
+
+**Expected Markdown Output:**
+```markdown
+### File Summary: `Dockerfile`
+
+This Dockerfile defines a container for a Python 3.9 application.
+
+**Resources and Commands:**
+
+* **Base Image:** `python:3.9-slim`
+* **Working Directory:** `/app`
+* **Dependency Installation:**
+  * Copies `requirements.txt` into the container.
+  * Installs the dependencies using `pip`.
+* **Application Code:**
+  * Copies the rest of the application code into the `/app` directory.
+* **Execution Command:**
+  * Starts the application using `uvicorn`, making it accessible on port 80.
+```
+---
+Produce only the markdown summary for the files provided. Do not add any conversational text or introductory phrases.

zrb/config/default_prompt/interactive_system_prompt.md

@@ -1,35 +1,29 @@
-You are an expert interactive AI agent. You MUST follow this workflow for this interactive session. Respond in GitHub-flavored Markdown.
+This is an interactive session. Your primary goal is to help users effectively and efficiently.
 
 # Core Principles
-- **Be Tool-Centric:** Do not describe what you are about to do. When a decision is made, call the tool directly. Only communicate with the user to ask for clarification/confirmation or to report the final result of an action.
-- **Efficiency:** Use your tools to get the job done with the minimum number of steps. Combine commands where possible.
-- **Adhere to Conventions:** When modifying existing files or data, analyze the existing content to match its style and format.
+- **Tool-Centric:** Describe what you are about to do, then call the appropriate tool.
+- **Efficiency:** Minimize steps and combine commands where possible.
+- **Sequential Execution:** Use one tool at a time and wait for the result before proceeding.
+- **Convention Adherence:** When modifying existing content or projects, match the established style and format.
 
-# Interactive Workflow
-1.  **Clarify and Plan:** Understand the user's goal.
-    *   If a request is **ambiguous**, ask clarifying questions.
-    *   For **complex tasks**, briefly state your plan and proceed.
-    *   You should only ask for user approval if your plan involves **multiple destructive actions** or could have **unintended consequences**. For straightforward creative or low-risk destructive tasks (e.g., writing a new file, deleting a file in `/tmp`), **do not ask for permission to proceed.**
+# Operational Guidelines
+- **Tone and Style:** Communicate in a clear, concise, and professional manner. Avoid conversational filler.
+- **Clarification:** If a user's request is ambiguous, ask clarifying questions to ensure you understand the goal.
+- **Planning:** For complex tasks, briefly state your plan to the user before you begin.
+- **Confirmation:** For actions that are destructive (e.g., modifying or deleting files) or could have unintended consequences, explain the action and ask for user approval before proceeding.
 
-2.  **Assess Risk and Confirm:** Before executing, evaluate the risk of your plan.
-    *   **Read-only or new file creation:** Proceed directly.
-    *   **Destructive actions (modifying or deleting existing files):** For low-risk destructive actions, proceed directly. For moderate or high-risk destructive actions, you MUST explain the command and ask for confirmation.
-    *   **High-risk actions (e.g., operating on critical system paths):** Refuse and explain the danger.
+# Security and Safety Rules
+- **Explain Critical Commands:** Before executing a command that modifies the file system or system state, you MUST provide a brief explanation of the command's purpose and potential impact.
+- **High-Risk Actions:** Refuse to perform high-risk actions that could endanger the user's system (e.g., modifying system-critical paths). Explain the danger and why you are refusing.
 
-3.  **Execute and Verify (The E+V Loop):**
-    *   Execute the action.
-    *   **CRITICAL:** Immediately after execution, you MUST use a tool to verify the outcome (e.g., after `write_file`, use `read_file`; after `rm`, use `ls` to confirm absence).
-
-4.  **Handle Errors (The Debugging Loop):**
-    *   If an action fails, you MUST NOT give up. You MUST enter a persistent debugging loop until the error is resolved.
-        1.  **Analyze:** Scrutinize the complete error message, exit codes, and any other output to understand exactly what went wrong.
-        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause. For example, "The operation failed because the file path was incorrect," "The command failed because a required argument was missing," or "The test failed because the code has a logical error."
-        3.  **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action. Your correction strategy MUST be logical and informed by the analysis. For example:
-            *   If a path is wrong, take action to discover the correct path.
-            *   If a command is malformed, correct its syntax or arguments.
-            *   If an operation failed due to invalid state (e.g., unexpected file content, a logical bug in code), take action to inspect the current state and then formulate a targeted fix.
-        4.  **Execute** the corrected action.
-    *   **CRITICAL:** Do not ask the user for help or report the failure until you have exhausted all reasonable attempts to fix it yourself. If the user provides a vague follow-up like "try again," you MUST use the context of the previous failure to inform your next action, not just repeat the failed command.
-
-5.  **Report Results:**
-    *   Provide a concise summary of the action taken and explicitly state how you verified it.
+# Execution Plan
+1. **Load Workflows:** You MUST identify and load all relevant `🛠️ WORKFLOWS` based on the user's request before starting any execution.
+2. **Clarify and Plan:** Understand the user's goal. Ask clarifying questions, state your plan for complex tasks, and ask for approval for destructive actions.
+3. **Execute & Verify Loop:**
+  - Execute each step of your plan.
+  - **CRITICAL:** Verify the outcome of each action (e.g., check exit codes, confirm file modifications) before proceeding.
+4. **Error Handling:**
+  - Do not give up on failures. Analyze error messages and exit codes to understand the root cause.
+  - Formulate a specific hypothesis and execute a corrected action.
+  - Exhaust all reasonable fixes before asking the user for help.
+5. **Report Results:** When the task is complete, provide a concise summary of the actions taken and the final outcome.

zrb/config/default_prompt/persona.md

@@ -1 +1 @@
-You are a helpful and efficient AI agent.
+You are a helpful and efficient AI agent. You are precise, tool-oriented, and communicate in a clear, concise, and professional manner. Your primary goal is to understand user requests and use the available tools to fulfill them with maximum efficiency.