zrb 1.13.1__py3-none-any.whl → 1.21.33__py3-none-any.whl

zrb/task/llm/config.py

@@ -1,20 +1,43 @@
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Callable
 
 if TYPE_CHECKING:
     from pydantic_ai.models import Model
     from pydantic_ai.settings import ModelSettings
 
-from zrb.attr.type import StrAttr, fstring
+from zrb.attr.type import BoolAttr, StrAttr, StrListAttr
 from zrb.config.llm_config import LLMConfig, llm_config
 from zrb.context.any_context import AnyContext
-from zrb.context.any_shared_context import AnySharedContext
-from zrb.util.attr import get_attr
+from zrb.util.attr import get_attr, get_bool_attr, get_str_list_attr
+
+
+def get_yolo_mode(
+    ctx: AnyContext,
+    yolo_mode_attr: (
+        Callable[[AnyContext], list[str] | bool | None] | StrListAttr | BoolAttr | None
+    ) = None,
+    render_yolo_mode: bool = True,
+) -> bool | list[str]:
+    if yolo_mode_attr is None:
+        return llm_config.default_yolo_mode
+    try:
+        return get_bool_attr(
+            ctx,
+            yolo_mode_attr,
+            False,
+            auto_render=render_yolo_mode,
+        )
+    except Exception:
+        return get_str_list_attr(
+            ctx,
+            yolo_mode_attr,
+            auto_render=render_yolo_mode,
+        )
 
 
 def get_model_settings(
     ctx: AnyContext,
     model_settings_attr: (
-        "ModelSettings | Callable[[AnySharedContext], ModelSettings] | None"
+        "ModelSettings | Callable[[AnyContext], ModelSettings] | None"
     ) = None,
 ) -> "ModelSettings | None":
     """Gets the model settings, resolving callables if necessary."""
@@ -47,7 +70,7 @@ def get_model_api_key(
 ) -> str | None:
     """Gets the model API key, rendering if configured."""
     api_key = get_attr(ctx, model_api_key_attr, None, auto_render=render_model_api_key)
-    if api_key is None and llm_config.default_api_key is not None:
+    if api_key is None and llm_config.default_model_api_key is not None:
         return llm_config.default_model_api_key
     if isinstance(api_key, str) or api_key is None:
         return api_key
@@ -56,18 +79,21 @@ def get_model_api_key(
 
 def get_model(
     ctx: AnyContext,
-    model_attr: "Callable[[AnySharedContext], Model | str | fstring] | Model | None",
+    model_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None",
     render_model: bool,
-    model_base_url_attr: StrAttr | None = None,
+    model_base_url_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None",
     render_model_base_url: bool = True,
-    model_api_key_attr: StrAttr | None = None,
+    model_api_key_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None" = None,
     render_model_api_key: bool = True,
-) -> "str | Model | None":
+    is_small_model: bool = False,
+) -> "str | Model":
     """Gets the model instance or name, handling defaults and configuration."""
     from pydantic_ai.models import Model
 
     model = get_attr(ctx, model_attr, None, auto_render=render_model)
     if model is None:
+        if is_small_model:
+            return llm_config.default_small_model
         return llm_config.default_model
     if isinstance(model, str):
         model_base_url = get_model_base_url(
@@ -76,11 +102,11 @@ def get_model(
         model_api_key = get_model_api_key(ctx, model_api_key_attr, render_model_api_key)
         new_llm_config = LLMConfig(
             default_model_name=model,
-            default_base_url=model_base_url,
-            default_api_key=model_api_key,
+            default_model_base_url=model_base_url,
+            default_model_api_key=model_api_key,
         )
         if model_base_url is None and model_api_key is None:
-            default_model_provider = llm_config.default_model_provider
+            default_model_provider = _get_default_model_provider(is_small_model)
             if default_model_provider is not None:
                 new_llm_config.set_default_model_provider(default_model_provider)
         return new_llm_config.default_model
@@ -88,3 +114,9 @@ def get_model(
     if isinstance(model, Model):
         return model
     raise ValueError(f"Invalid model type resolved: {type(model)}, value: {model}")
+
+
+def _get_default_model_provider(is_small_model: bool = False):
+    if is_small_model:
+        return llm_config.default_small_model_provider
+    return llm_config.default_model_provider

zrb/task/llm/conversation_history.py

@@ -1,16 +1,73 @@
 import json
+import os
 from collections.abc import Callable
-from copy import deepcopy
 from typing import Any
 
 from zrb.attr.type import StrAttr
+from zrb.config.llm_context.config import llm_context_config
 from zrb.context.any_context import AnyContext
-from zrb.context.any_shared_context import AnySharedContext
 from zrb.task.llm.conversation_history_model import ConversationHistory
 from zrb.task.llm.typing import ListOfDict
 from zrb.util.attr import get_str_attr
-from zrb.util.file import write_file
+from zrb.util.file import read_file, write_file
+from zrb.util.markdown import make_markdown_section
 from zrb.util.run import run_async
+from zrb.xcom.xcom import Xcom
+
+
+def _get_global_subagent_messages_xcom(ctx: AnyContext) -> Xcom:
+    if "_global_subagents" not in ctx.xcom:
+        ctx.xcom["_global_subagents"] = Xcom([{}])
+    if not isinstance(ctx.xcom["_global_subagents"], Xcom):
+        raise ValueError("ctx.xcom._global_subagents must be an Xcom")
+    return ctx.xcom["_global_subagents"]
+
+
+def inject_subagent_history_into_ctx(
+    ctx: AnyContext, conversation_history: ConversationHistory
+):
+    subagent_messages_xcom = _get_global_subagent_messages_xcom(ctx)
+    existing_subagent_history = subagent_messages_xcom.get({})
+    subagent_messages_xcom.set(
+        {**existing_subagent_history, **conversation_history.subagent_history}
+    )
+
+
+def set_ctx_subagent_history(ctx: AnyContext, subagent_name: str, messages: ListOfDict):
+    subagent_messages_xcom = _get_global_subagent_messages_xcom(ctx)
+    subagent_history = subagent_messages_xcom.get({})
+    subagent_history[subagent_name] = messages
+    subagent_messages_xcom.set(subagent_history)
+
+
+def get_subagent_histories_from_ctx(ctx: AnyContext) -> dict[str, ListOfDict]:
+    subagent_messsages_xcom = _get_global_subagent_messages_xcom(ctx)
+    return subagent_messsages_xcom.get({})
+
+
+def inject_conversation_history_notes(conversation_history: ConversationHistory):
+    conversation_history.long_term_note = _fetch_long_term_note(
+        conversation_history.project_path
+    )
+    conversation_history.contextual_note = _fetch_contextual_note(
+        conversation_history.project_path
+    )
+
+
+def _fetch_long_term_note(project_path: str) -> str:
+    contexts = llm_context_config.get_notes(cwd=project_path)
+    return contexts.get("/", "")
+
+
+def _fetch_contextual_note(project_path: str) -> str:
+    contexts = llm_context_config.get_notes(cwd=project_path)
+    return "\n".join(
+        [
+            make_markdown_section(header, content)
+            for header, content in contexts.items()
+            if header != "/"
+        ]
+    )
 
 
 def get_history_file(
@@ -27,16 +84,62 @@ def get_history_file(
     )
 
 
+async def _read_from_source(
+    ctx: AnyContext,
+    reader: (
+        Callable[[AnyContext], ConversationHistory | dict[str, Any] | list | None]
+        | None
+    ),
+    file_path: str | None,
+) -> "ConversationHistory | None":
+    # Priority 1: Reader function
+    if reader:
+        try:
+            raw_data = await run_async(reader(ctx))
+            if raw_data:
+                instance = ConversationHistory.parse_and_validate(
+                    ctx, raw_data, "reader"
+                )
+                if instance:
+                    return instance
+        except Exception as e:
+            ctx.log_warning(
+                f"Error executing conversation history reader: {e}. Ignoring."
+            )
+    # Priority 2: History file
+    if file_path and os.path.isfile(file_path):
+        try:
+            content = read_file(file_path)
+            raw_data = json.loads(content)
+            instance = ConversationHistory.parse_and_validate(
+                ctx, raw_data, f"file '{file_path}'"
+            )
+            if instance:
+                return instance
+        except json.JSONDecodeError:
+            ctx.log_warning(
+                f"Could not decode JSON from history file '{file_path}'. "
+                "Ignoring file content."
+            )
+        except Exception as e:
+            ctx.log_warning(
+                f"Error reading history file '{file_path}': {e}. "
+                "Ignoring file content."
+            )
+    # Fallback: Return default value
+    return None
+
+
 async def read_conversation_history(
     ctx: AnyContext,
     conversation_history_reader: (
-        Callable[[AnySharedContext], ConversationHistory | dict | list | None] | None
+        Callable[[AnyContext], ConversationHistory | dict | list | None] | None
     ),
     conversation_history_file_attr: StrAttr | None,
     render_history_file: bool,
     conversation_history_attr: (
         ConversationHistory
-        | Callable[[AnySharedContext], ConversationHistory | dict | list]
+        | Callable[[AnyContext], ConversationHistory | dict | list]
         | dict
         | list
     ),
@@ -46,7 +149,7 @@ async def read_conversation_history(
         ctx, conversation_history_file_attr, render_history_file
     )
     # Use the class method defined above
-    history_data = await ConversationHistory.read_from_source(
+    history_data = await _read_from_source(
         ctx=ctx,
         reader=conversation_history_reader,
         file_path=history_file,
@@ -80,7 +183,7 @@ async def write_conversation_history(
     ctx: AnyContext,
     history_data: ConversationHistory,
     conversation_history_writer: (
-        Callable[[AnySharedContext, ConversationHistory], None] | None
+        Callable[[AnyContext, ConversationHistory], None] | None
     ),
     conversation_history_file_attr: StrAttr | None,
     render_history_file: bool,
@@ -95,28 +198,6 @@ async def write_conversation_history(
         write_file(history_file, json.dumps(history_data.to_dict(), indent=2))
 
 
-def replace_system_prompt_in_history(
-    history_list: ListOfDict, replacement: str = "<main LLM system prompt>"
-) -> ListOfDict:
-    """
-    Returns a new history list where any part with part_kind 'system-prompt'
-    has its 'content' replaced with the given replacement string.
-    Args:
-        history: List of history items (each item is a dict with a 'parts' list).
-        replacement: The string to use in place of system-prompt content.
-
-    Returns:
-        A deep-copied list of history items with system-prompt content replaced.
-    """
-    new_history = deepcopy(history_list)
-    for item in new_history:
-        parts = item.get("parts", [])
-        for part in parts:
-            if part.get("part_kind") == "system-prompt":
-                part["content"] = replacement
-    return new_history
-
-
 def count_part_in_history_list(history_list: ListOfDict) -> int:
     """Calculates the total number of 'parts' in a history list."""
     history_part_len = 0

zrb/task/llm/conversation_history_model.py

@@ -1,90 +1,38 @@
 import json
 import os
-from collections.abc import Callable
 from typing import Any
 
-from zrb.config.llm_context.config import llm_context_config
 from zrb.context.any_context import AnyContext
 from zrb.task.llm.typing import ListOfDict
-from zrb.util.file import read_file
-from zrb.util.llm.prompt import make_prompt_section
-from zrb.util.run import run_async
 
 
 class ConversationHistory:
 
     def __init__(
         self,
-        past_conversation_summary: str = "",
-        past_conversation_transcript: str = "",
         history: ListOfDict | None = None,
         contextual_note: str | None = None,
         long_term_note: str | None = None,
         project_path: str | None = None,
+        subagent_history: dict[str, ListOfDict] | None = None,
     ):
-        self.past_conversation_transcript = past_conversation_transcript
-        self.past_conversation_summary = past_conversation_summary
         self.history = history if history is not None else []
         self.contextual_note = contextual_note if contextual_note is not None else ""
         self.long_term_note = long_term_note if long_term_note is not None else ""
         self.project_path = project_path if project_path is not None else os.getcwd()
+        self.subagent_history = subagent_history if subagent_history is not None else {}
 
     def to_dict(self) -> dict[str, Any]:
         return {
-            "past_conversation_summary": self.past_conversation_summary,
-            "past_conversation_transcript": self.past_conversation_transcript,
             "history": self.history,
             "contextual_note": self.contextual_note,
             "long_term_note": self.long_term_note,
+            "subagent_history": self.subagent_history,
         }
 
     def model_dump_json(self, indent: int = 2) -> str:
         return json.dumps(self.to_dict(), indent=indent)
 
-    @classmethod
-    async def read_from_source(
-        cls,
-        ctx: AnyContext,
-        reader: Callable[[AnyContext], dict[str, Any] | list | None] | None,
-        file_path: str | None,
-    ) -> "ConversationHistory | None":
-        # Priority 1: Reader function
-        if reader:
-            try:
-                raw_data = await run_async(reader(ctx))
-                if raw_data:
-                    instance = cls.parse_and_validate(ctx, raw_data, "reader")
-                    if instance:
-                        return instance
-            except Exception as e:
-                ctx.log_warning(
-                    f"Error executing conversation history reader: {e}. Ignoring."
-                )
-        # Priority 2: History file
-        if file_path and os.path.isfile(file_path):
-            try:
-                content = read_file(file_path)
-                raw_data = json.loads(content)
-                instance = cls.parse_and_validate(ctx, raw_data, f"file '{file_path}'")
-                if instance:
-                    return instance
-            except json.JSONDecodeError:
-                ctx.log_warning(
-                    f"Could not decode JSON from history file '{file_path}'. "
-                    "Ignoring file content."
-                )
-            except Exception as e:
-                ctx.log_warning(
-                    f"Error reading history file '{file_path}': {e}. "
-                    "Ignoring file content."
-                )
-        # Fallback: Return default value
-        return None
-
-    def fetch_newest_notes(self):
-        self._fetch_long_term_note()
-        self._fetch_contextual_note()
-
     @classmethod
     def parse_and_validate(
         cls, ctx: AnyContext, data: Any, source: str
@@ -93,15 +41,11 @@ class ConversationHistory:
             if isinstance(data, cls):
                 return data  # Already a valid instance
             if isinstance(data, dict):
-                # This handles both the new format and the old {'context': ..., 'history': ...}
                 return cls(
-                    past_conversation_summary=data.get("past_conversation_summary", ""),
-                    past_conversation_transcript=data.get(
-                        "past_conversation_transcript", ""
-                    ),
                     history=data.get("history", data.get("messages", [])),
                     contextual_note=data.get("contextual_note", ""),
                     long_term_note=data.get("long_term_note", ""),
+                    subagent_history=data.get("subagent_history", {}),
                 )
             elif isinstance(data, list):
                 # Handle very old format (just a list) - wrap it
@@ -121,122 +65,3 @@ class ConversationHistory:
                 f"Error validating/parsing history data from {source}: {e}. Ignoring."
             )
         return cls()
-
-    def write_past_conversation_summary(self, past_conversation_summary: str):
-        """
-        Write or update the past conversation summary.
-
-        Use this tool to store or update a summary of previous conversations for
-        future reference. This is useful for providing context to LLMs or other tools
-        that need a concise history.
-
-        Args:
-            past_conversation_summary (str): The summary text to store.
-
-        Returns:
-            str: A JSON object indicating the success or failure of the operation.
-
-        Raises:
-            Exception: If the summary cannot be written.
-        """
-        self.past_conversation_summary = past_conversation_summary
-        return json.dumps({"success": True})
-
-    def write_past_conversation_transcript(self, past_conversation_transcript: str):
-        """
-        Write or update the past conversation transcript.
-
-        Use this tool to store or update the full transcript of previous conversations.
-        This is useful for providing detailed context to LLMs or for record-keeping.
-
-        Args:
-            past_conversation_transcript (str): The transcript text to store.
-
-        Returns:
-            str: A JSON object indicating the success or failure of the operation.
-
-        Raises:
-            Exception: If the transcript cannot be written.
-        """
-        self.past_conversation_transcript = past_conversation_transcript
-        return json.dumps({"success": True})
-
-    def read_long_term_note(self) -> str:
-        """
-        Read the content of the long-term references.
-
-        This tool helps you retrieve knowledge or notes stored for long-term reference.
-        If the note does not exist, you may want to create it using the write tool.
-
-        Returns:
-            str: JSON with content of the notes.
-
-        Raises:
-            Exception: If the note cannot be read.
-        """
-        return json.dumps({"content": self._fetch_long_term_note()})
-
-    def write_long_term_note(self, content: str) -> str:
-        """
-        Write the entire content of the long-term references.
-        This will overwrite any existing long-term notes.
-
-        Args:
-            content (str): The full content of the long-term notes.
-
-        Returns:
-            str: JSON indicating success.
-        """
-        llm_context_config.write_context(content, context_path="/")
-        return json.dumps({"success": True})
-
-    def read_contextual_note(self) -> str:
-        """
-        Read the content of the contextual references for the current project.
-
-        This tool helps you retrieve knowledge or notes stored for contextual reference.
-        If the note does not exist, you may want to create it using the write tool.
-
-        Returns:
-            str: JSON with content of the notes.
-
-        Raises:
-            Exception: If the note cannot be read.
-        """
-        return json.dumps({"content": self._fetch_contextual_note()})
-
-    def write_contextual_note(
-        self, content: str, context_path: str | None = None
-    ) -> str:
-        """
-        Write the entire content of the contextual references for a specific path.
-        This will overwrite any existing contextual notes for that path.
-
-        Args:
-            content (str): The full content of the contextual notes.
-            context_path (str, optional): The directory path for the context.
-                                        Defaults to the current project path.
-
-        Returns:
-            str: JSON indicating success.
-        """
-        if context_path is None:
-            context_path = self.project_path
-        llm_context_config.write_context(content, context_path=context_path)
-        return json.dumps({"success": True})
-
-    def _fetch_long_term_note(self):
-        contexts = llm_context_config.get_contexts(cwd=self.project_path)
-        self.long_term_note = contexts.get("/", "")
-        return self.long_term_note
-
-    def _fetch_contextual_note(self):
-        contexts = llm_context_config.get_contexts(cwd=self.project_path)
-        self.contextual_note = "\n".join(
-            [
-                make_prompt_section(header, content)
-                for header, content in contexts.items()
-                if header != "/"
-            ]
-        )
-        return self.contextual_note

zrb/task/llm/default_workflow/coding/workflow.md

@@ -0,0 +1,41 @@
+---
+description: "A comprehensive workflow for software engineering tasks, including writing, modifying, and debugging code, as well as creating new applications. ALWAYS activate this workflow whenever you need to deal with software engineering tasks."
+---
+
+This workflow provides a structured approach to software engineering tasks. Adhere to these guidelines to deliver high-quality, idiomatic code that respects the project's existing patterns and conventions.
+
+# Workflow Loading Strategy
+
+This is a general-purpose coding workflow. For tasks involving specific languages or tools, you **MUST** load the relevant specialized workflows.
+
+- **If the task involves Python:** Load the `python` workflow.
+- **If the task involves Git:** Load the `git` workflow.
+- **If the task involves shell scripting:** Load the `shell` workflow.
+- **If the task involves Go:** Load the `golang` workflow.
+- **If the task involves Java:** Load the `java` workflow.
+- **If the task involves Javascript/Typescript:** Load the `javascript` workflow.
+- **If the task involves HTML/CSS:** Load the `html-css` workflow.
+- **If the task involves Rust:** Load the `rust` workflow.
+
+Always consider if a more specific workflow is available and appropriate for the task at hand.
+
+# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
+- **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
+- **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
+
+# Software Engineering Tasks
+When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
+1. **Understand & Strategize:** Think about the user's request and the relevant codebase context. When the task involves **complex refactoring, codebase exploration or system-wide analysis**, your **first and primary tool** must be 'codebase_investigator'. Use it to build a comprehensive understanding of the code, its structure, and dependencies. For **simple, targeted searches** (like finding a specific function name, file path, or variable declaration), you should use 'search_file_content' or 'glob' directly.
+2. **Plan:** Build a coherent and grounded (based on the understanding in step 1) plan for how you intend to resolve the user's task. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should use an iterative development process that includes writing unit tests to verify your changes. Use output logs or debug statements as part of this process to arrive at a solution.
+3. **Implement:** Use the available tools (e.g., 'replace_in_file', 'write_to_file' 'run_shell_command' ...) to act on the plan, strictly adhering to the project's established conventions (detailed under 'Core Mandates').
+4. **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands.
+5. **Verify (Standards):** VERY IMPORTANT: After making code changes, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. If unsure about these commands, you can ask the user if they'd like you to run them and if so how to.
+6. **Finalize:** After all verification passes, consider the task complete. Do not remove or revert any changes or created files (like tests). Await the user's next instruction.

zrb/task/llm/default_workflow/copywriting/workflow.md

@@ -0,0 +1,68 @@
+---
+description: "A workflow for creating, refining, and organizing textual content."
+---
+Follow this workflow to produce content that is not just correct, but compelling, clear, and perfectly suited to its purpose.
+
+# Core Mandates
+
+- **Audience-First:** Always understand who you're writing for and what they need to know
+- **Purpose-Driven:** Every piece of content must serve a clear objective
+- **Quality Standards:** Deliver polished, professional content that meets the highest standards
+- **Iterative Refinement:** Content improves through multiple rounds of review and editing
+
+# Tool Usage Guideline
+- Use `read_from_file` to analyze existing content and style guides
+- Use `write_to_file` for creating new content drafts
+- Use `replace_in_file` for targeted edits and refinements
+
+# Step 1: Understand Intent and Audience
+
+1. **Define the Goal:** What is this text supposed to achieve? (e.g., persuade, inform, entertain, sell). If the user is vague, ask for clarification.
+2. **Identify the Audience:** Who are you writing for? (e.g., experts, beginners, customers). This dictates your tone, vocabulary, and level of detail.
+3. **Determine the Tone:** Choose a voice that serves the goal and resonates with the audience (e.g., formal, witty, technical, urgent).
+4. **Analyze Existing Content:** Review any provided examples, style guides, or reference materials to understand established patterns.
+
+# Step 2: Plan and Outline
+
+1. **Create Logical Structure:** Develop an outline that flows naturally from introduction to conclusion
+2. **Key Sections:** Identify main talking points and supporting arguments
+3. **Call-to-Action:** Define what you want the reader to do or think after reading
+4. **Get Approval:** Present the outline to the user for confirmation before proceeding
+
+# Step 3: Draft with Purpose
+
+1. **Hook the Reader:** Start with a strong opening that grabs attention
+2. **Use Active Voice:** Make your writing direct and energetic
+3. **Show, Don't Just Tell:** Use examples, stories, and data to illustrate your points
+4. **Maintain Consistency:** Stick to the established tone and style throughout
+
+# Step 4: Refine and Polish
+
+1. **Read Aloud:** Catch awkward phrasing and grammatical errors
+2. **Cut Mercilessly:** Remove anything that doesn't serve the goal
+3. **Enhance Readability:** Use short paragraphs, headings, bullet points, and bold text
+4. **Verify Accuracy:** Ensure all facts, figures, and claims are correct
+
+# Step 5: Task-Specific Execution
+
+## Summarization
+- Distill the essence while preserving key information
+- Be objective and ruthless in cutting fluff
+- Maintain the original meaning and context
+
+## Proofreading
+- Correct grammar, spelling, and punctuation
+- Improve sentence flow and clarity
+- Preserve the original meaning and voice
+
+## Refining/Editing
+- Sharpen the author's message
+- Strengthen arguments and improve clarity
+- Ensure consistent tone while respecting the original voice
+
+# Step 6: Finalize and Deliver
+
+- Present the final content to the user
+- Be prepared to make additional refinements based on feedback
+- Ensure the content meets all stated objectives
+- Confirm the content is ready for its intended use