tunacode-cli 0.0.50__py3-none-any.whl → 0.0.53__py3-none-any.whl

tunacode_cli-0.0.53.dist-info/RECORD

@@ -0,0 +1,123 @@
+tunacode/__init__.py,sha256=yUul8igNYMfUrHnYfioIGAqvrH8b5BKiO_pt1wVnmd0,119
+tunacode/constants.py,sha256=PTd740UJlY1KKeK6DZRirEY1nPpCjZits6ZeZ9p41uc,5968
+tunacode/context.py,sha256=YtfRjUiqsSkk2k9Nn_pjb_m-AXyh6XcOBOJWtFI0wVw,2405
+tunacode/exceptions.py,sha256=oDO1SVKOgjcKIylwqdbqh_g5my4roU5mB9Nv4n_Vb0s,3877
+tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tunacode/setup.py,sha256=a5S-uGkVYoBTvH9nsqMBgAFoH4CILOgfKvgS30qGnoU,1978
+tunacode/types.py,sha256=bCJ0mq1iQKa42fhBN5Pimkx0FV0f2J3-qRzbMzFhmBw,8499
+tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
+tunacode/cli/main.py,sha256=4MF4nGEU-CB83ckIl85AY-015EeUJHrE_UdbuSa9wCU,2968
+tunacode/cli/repl.py,sha256=gEepV-vD0iH0rdRkz0DeLmyoHhJSlbZCMonRda4nraQ,15841
+tunacode/cli/commands/__init__.py,sha256=zmE9JcJ9Qd2xJhgdS4jMDJOoZsrAZmL5MAFxbKkk7F8,1670
+tunacode/cli/commands/base.py,sha256=Ge_lNQA-GDfcb1Ap1oznCH3UrifBiHH3bA9DNL-tCDw,2519
+tunacode/cli/commands/registry.py,sha256=XgewkwpljAl9MYemKpWrOW2pSm9uGOPrDKckqcstDY4,9267
+tunacode/cli/commands/template_shortcut.py,sha256=ApYTPkDVBRaLxa7rWaPrsGcJdkR7eg09k18KyTjYg_E,3447
+tunacode/cli/commands/implementations/__init__.py,sha256=DHjQm1f14OV1go0ZyqacFa3yfnGWH7LZFbZVVQZ5Iw0,1011
+tunacode/cli/commands/implementations/conversation.py,sha256=ZijCNaRi1p5v1Q-IaVHtU2_BripSW3JCVKTtqFkOUjg,4676
+tunacode/cli/commands/implementations/debug.py,sha256=ornvceGF4GbJd2OJXnnT9i9KpHBAMJUYNs9wNhzViGM,6764
+tunacode/cli/commands/implementations/development.py,sha256=I8jHgYY3VgjTU8its0D0ysruuVqKbNTBur0JjPIUIZA,2844
+tunacode/cli/commands/implementations/model.py,sha256=uthx6IX9KwgwywNTDklkJpqCbaTX9h1_p-eVmqL73WQ,2245
+tunacode/cli/commands/implementations/system.py,sha256=2cGw5iCJO3aNhXTFF28CgAIyLgslvHmpfyL2ZHVB6oQ,7903
+tunacode/cli/commands/implementations/template.py,sha256=YeFOjbKKfPswPCHPvlDUwXvg6J0MesyAyVsujiIgPbU,5482
+tunacode/cli/commands/implementations/todo.py,sha256=Dtz5bgcuK2VXGPWEBBZQgnWUMYkRXNzTGf_qkVPLF2U,8125
+tunacode/cli/repl_components/__init__.py,sha256=5ZjPJ3yUvZ5x6Vg9EYJ03-tdxfEEdmfradCmwSlVY3E,334
+tunacode/cli/repl_components/command_parser.py,sha256=SuDRP-nt8Sq5klI4-tXkllN_4nVzji5VJ-dQvbxDmDw,880
+tunacode/cli/repl_components/error_recovery.py,sha256=yPoWXzuMi6B_Pwlm1wnFIJV55lJEOChvHGDca4XtoVI,3064
+tunacode/cli/repl_components/output_display.py,sha256=SGhP7Hc1ymfZf-AvrkELgdJCZ3UVEzTx2Y6W737zdoY,816
+tunacode/cli/repl_components/tool_executor.py,sha256=TrB1tNAKsKdumL8l0yOJikA7BgSE1rBD42bKfVwl10I,2995
+tunacode/configuration/__init__.py,sha256=MbVXy8bGu0yKehzgdgZ_mfWlYGvIdb1dY2Ly75nfuPE,17
+tunacode/configuration/defaults.py,sha256=5TUeSqMTeA7kW7gz9hND_H4s9Key0_khPvc6mNFMlZc,838
+tunacode/configuration/models.py,sha256=buH8ZquvcYI3OQBDIZeJ08cu00rSCeNABtUwl3VQS0E,4103
+tunacode/configuration/settings.py,sha256=9wtIWBlLhW_ZBlLx-GA4XDfVZyGj2Gs6Zk49vk-nHq0,1047
+tunacode/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tunacode/core/code_index.py,sha256=jgAx3lSWP_DwnyiP5Jkm1YvX4JJyI4teMzlNrJSpEOA,15661
+tunacode/core/state.py,sha256=pjrJgjqdQF3JTb4nFERVGl-idlYsQIMfNGct0qfbEu0,6162
+tunacode/core/tool_handler.py,sha256=FqA3w8M_fhpyOQKJIgl_8MAhSFVEguufbZH6gm_b7NI,2932
+tunacode/core/agents/__init__.py,sha256=UUJiPYb91arwziSpjd7vIk7XNGA_4HQbsOIbskSqevA,149
+tunacode/core/agents/main.py,sha256=6mvdtqmYs_hA4drZa6MFF5w8RUc5bTiwbs7TNsuPyzQ,28964
+tunacode/core/agents/utils.py,sha256=dJsdbvWs48vxQpwAtUjJLMj7_huv12Mx3E2CEgwoK94,14467
+tunacode/core/agents/agent_components/__init__.py,sha256=V9C_BDKumgA8OZf69NJ1J_v6jbzCtn9gqdFiC1l0RZw,911
+tunacode/core/agents/agent_components/agent_config.py,sha256=6m2RBZ7Y-0p_KFBVmfPW4ZGLGzTAw3YFQ4i94qsqEpM,4373
+tunacode/core/agents/agent_components/json_tool_parser.py,sha256=HuyNT0rs-ppx_gLAI2e0XMVGbR_F0WXZfP3sx38VoMg,3447
+tunacode/core/agents/agent_components/message_handler.py,sha256=KJGOtb9VhumgZpxxwO45HrKLhU9_MwuoWRsSQwJviNU,3704
+tunacode/core/agents/agent_components/node_processor.py,sha256=hl5n0M1QgBNbFB9-ME1otyw4se9MVVHbwh98lFK9p2A,21002
+tunacode/core/agents/agent_components/response_state.py,sha256=_C2loLeyZHMFHwjGny4h0dI02UoFJcJAVaabkh9H9JQ,343
+tunacode/core/agents/agent_components/result_wrapper.py,sha256=9CFK0wpsfZx2WT4PBHfkSv22GxL1gAQuUYVMlmYtCJU,1761
+tunacode/core/agents/agent_components/task_completion.py,sha256=BSnjNEFbxlzgzcXdjdTVGeCr1RpCiAaEp_D7f5FXa5Q,819
+tunacode/core/agents/agent_components/tool_buffer.py,sha256=09FNtC6zTjiJOL_2CY0b7KDgwdNayGPV6jbENKH6Unc,766
+tunacode/core/agents/agent_components/tool_executor.py,sha256=LlzDwgSLLawwPZQqJ4vfLf-16nhwIiuN8zm8iCeBf1Y,1849
+tunacode/core/background/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tunacode/core/background/manager.py,sha256=AxNcuuE7T2pqeI2lLIGJgaS_jEw60YzBfZY9EOY54fc,1160
+tunacode/core/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tunacode/core/logging/__init__.py,sha256=vykmcZPOo_FhIPJvPuH0gbUqprpGp9Sbrj13X0iOil4,709
+tunacode/core/logging/config.py,sha256=bhJ6KYrEliKC5BehXKXZHHPBJUBX0g5O3uxbr8qUKQ0,2515
+tunacode/core/logging/formatters.py,sha256=uWx-M0jSvsAVo5JVdCK1VIVawXNONjJ2CvMwPuuUTg8,1236
+tunacode/core/logging/handlers.py,sha256=lkLczpcI6kSammSdjrCccosGMrRdcAA_3UmuTOiPnxg,3788
+tunacode/core/logging/logger.py,sha256=9RjRuX0GoUojRJ8WnJGQPFdXiluiJMCoFmvc8xEioB8,142
+tunacode/core/setup/__init__.py,sha256=seoWYpRonptxNyApapS-yGz4o3jTj8vLsRPCTUO4siM,439
+tunacode/core/setup/agent_setup.py,sha256=tpOIW85C6o1m8pwAZQBIMKxKIyBUOpHHn4JJmDBFH3Q,1403
+tunacode/core/setup/base.py,sha256=FMjBQQS_q3KOxHqfg7NJGmKq-1nxC40htiPZprzTu7I,970
+tunacode/core/setup/config_setup.py,sha256=G6ByWXQNc8UszwnYfFKHsufw4ja8yLCU769y_cq5FZ8,14838
+tunacode/core/setup/coordinator.py,sha256=oVTN2xIeJERXitVJpkIk9tDGLs1D1bxIRmaogJwZJFI,2049
+tunacode/core/setup/environment_setup.py,sha256=n3IrObKEynHZSwtUJ1FddMg2C4sHz7ca42awemImV8s,2225
+tunacode/core/setup/git_safety_setup.py,sha256=uBvcvw3THfduGUW51rprFt13Qw3HoekWe_2jTcpK3no,7187
+tunacode/core/setup/template_setup.py,sha256=0lDGhNVCvGN7ykqHnl3pj4CONH3I2PvMzkmIZibfSoc,2640
+tunacode/core/token_usage/api_response_parser.py,sha256=plLltHg4zGVzxjv3MFj45bbd-NOJeT_v3P0Ki4zlvn4,1831
+tunacode/core/token_usage/cost_calculator.py,sha256=RjO-O0JENBuGOrWP7QgBZlZxeXC-PAIr8tj_9p_BxOU,2058
+tunacode/core/token_usage/usage_tracker.py,sha256=G6lt9VXnS3JcXsiPTwuS3v1YptI_7gfV78f08jX22yU,5932
+tunacode/prompts/system.md,sha256=dGKTnJeNuYG4MyGbc5NPaMYSZ27fLhJOml86rp8AffU,23873
+tunacode/services/__init__.py,sha256=w_E8QK6RnvKSvU866eDe8BCRV26rAm4d3R-Yg06OWCU,19
+tunacode/services/mcp.py,sha256=R48X73KQjQ9vwhBrtbWHSBl-4K99QXmbIhh5J_1Gezo,3046
+tunacode/templates/__init__.py,sha256=ssEOPrPjyCywtKI-QFcoqcWhMjlfI5TbI8Ip0_wyqGM,241
+tunacode/templates/loader.py,sha256=6_Dk4jX47_GKUAWxlHG2Mzkl9lkXFUOiAdlcJqb6rBA,6765
+tunacode/tools/__init__.py,sha256=ECBuUWWF1JjHW42CCceaPKgVTQyuljbz3RlhuA2fe2s,314
+tunacode/tools/base.py,sha256=DhlanZZZxU2JJaBOwwyGFKMUcoCWR_CzLuwVeSXC0Go,7297
+tunacode/tools/bash.py,sha256=mgZqugfDFevZ4BETuUv90pzXvtq7qKGUGFiuDxzmytk,8766
+tunacode/tools/glob.py,sha256=mQwVGC8dfvzwzUOeTikfnHhExnLcYnGQwDoHOWrt_fE,10342
+tunacode/tools/grep.py,sha256=kvfhO41k4gIg5rxyBECE-IWkyc3IwtWYly3Q8nN4SuM,17212
+tunacode/tools/list_dir.py,sha256=1kNqzYCNlcA5rqXIEVqcjQy6QxlLZLj5AG6YIECfwio,7217
+tunacode/tools/read_file.py,sha256=z2omev9xzj4-0GG9mRssD13rj-Aa1c-pszFi2Z7Hxvk,3268
+tunacode/tools/read_file_async_poc.py,sha256=2v2ckLQlwahgPGWGdE2c5Es37B35Y7zWdseZwT46E1E,6453
+tunacode/tools/run_command.py,sha256=7UvXjFQI1Av4vceXx48MbQCTrsFNj4PlygTAAhNDYIA,4376
+tunacode/tools/todo.py,sha256=kHYtipmPBxBURrBMbyH92yjOE6cKvrQuq9w-gSrOaLI,13179
+tunacode/tools/update_file.py,sha256=bW1MhTzRjBDjJzqQ6A1yCVEbkr1oIqtEC8uqcg_rfY4,3957
+tunacode/tools/write_file.py,sha256=prL6u8XOi9ZyPU-YNlG9YMLbSLrDJXDRuDX73ncXh-k,2699
+tunacode/tools/grep_components/__init__.py,sha256=qy3kwzxOiE6ydlRzpCC39TaIp5BJc5X_bRfXukiu4eM,266
+tunacode/tools/grep_components/file_filter.py,sha256=-XYlmVLOipjuAGdLhHDApLMKZJ1qtlzRUXvOvHc7VYU,3152
+tunacode/tools/grep_components/pattern_matcher.py,sha256=ZvEUqBZ6UWf9wZzb1DIRGSTFQuJCBV0GJG3DVG4r4Ss,5177
+tunacode/tools/grep_components/result_formatter.py,sha256=aa0tJitbG9IalWYWKG0nInRmZnp8HtBREOeMpAireVg,1641
+tunacode/tools/grep_components/search_result.py,sha256=xzb_htSANuPIPVWViPAqIMsCCWVA8loxWdaZOA8RqMs,869
+tunacode/ui/__init__.py,sha256=aRNE2pS50nFAX6y--rSGMNYwhz905g14gRd6g4BolYU,13
+tunacode/ui/completers.py,sha256=18f1Im5210-b-qNKyCoOMnSjW99FXNoF0DtgRvEWTm0,4901
+tunacode/ui/console.py,sha256=wLiJ9cVrWHS0zNadqbcXnsg0T2wj4xLACg17YAYLmU4,2574
+tunacode/ui/constants.py,sha256=A76B_KpM8jCuBYRg4cPmhi8_j6LLyWttO7_jjv47r3w,421
+tunacode/ui/decorators.py,sha256=jJDNztO8MyX_IG1nqXAL8-sQUFjaAzBnc5BsM3ioX24,1955
+tunacode/ui/input.py,sha256=NCZlj5qzNPy0gsSeGKeDNdAOMKZVGph8Z-UBXhX-Sbk,3020
+tunacode/ui/keybindings.py,sha256=ylvZ2kj2IWfOMrxPWBSbckEy9YVow66dni7wkj8vzbw,3046
+tunacode/ui/lexers.py,sha256=tmg4ic1enyTRLzanN5QPP7D_0n12YjX_8ZhsffzhXA4,1340
+tunacode/ui/logging_compat.py,sha256=5v6lcjVaG1CxdY1Zm9FAGr9H7Sy-tP6ihGfhP-5YvAY,1406
+tunacode/ui/output.py,sha256=vXfkPfQWmQzkmfGkY6snAk7auLgN8E7XEGUc-YVjTlM,5604
+tunacode/ui/panels.py,sha256=8D5w0dwzE1F3Li88Bkl-g6dHlK-Q-9DEl2n2EqMkVRk,9588
+tunacode/ui/prompt_manager.py,sha256=489r-WtuR3gdaugEr1lSV7SvtmXF2IlhDQckvzjYG2c,4676
+tunacode/ui/tool_ui.py,sha256=bLydo5Y42b2gbUMP2kM6m_stIkj4Q1wbwaqO-1P6O1g,7198
+tunacode/ui/utils.py,sha256=yvoCTz8AOdRfV0XIqUX3sgg88g_wntV9yhnQP6WzAVs,114
+tunacode/ui/validators.py,sha256=MMIMT1I2v0l2jIy-gxX_4GSApvUTi8XWIOACr_dmoBA,758
+tunacode/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tunacode/utils/bm25.py,sha256=fd59YQXovC8rXwZrdoqIAfFrLn_WCVjzCh0pkU22APE,1966
+tunacode/utils/diff_utils.py,sha256=V9QqQ0q4MfabVTnWptF3IXDp3estnfOKcJtDe_Sj14I,2372
+tunacode/utils/file_utils.py,sha256=84g-MQRzmBI2aG_CuXsDl2OhvvWoSL7YdL5Kz_UKSwk,979
+tunacode/utils/import_cache.py,sha256=q_xjJbtju05YbFopLDSkIo1hOtCx3DOTl3GQE5FFDgs,295
+tunacode/utils/message_utils.py,sha256=qb_EgPRq5a4pbQNcCLhmfcQVQ6vjekjsfgKrhIiszGQ,610
+tunacode/utils/retry.py,sha256=AHdUzY6m-mwlT4OPXdtWWMAafL_NeS7JAMORGyM8c5k,4931
+tunacode/utils/ripgrep.py,sha256=AXUs2FFt0A7KBV996deS8wreIlUzKOlAHJmwrcAr4No,583
+tunacode/utils/security.py,sha256=i3eGKg4o-qY2S_ObTlEaHO93q14iBfiPXR5O7srHn58,6579
+tunacode/utils/system.py,sha256=J8KqJ4ZqQrNSnM5rrJxPeMk9z2xQQp6dWtI1SKBY1-0,11121
+tunacode/utils/text_utils.py,sha256=HAwlT4QMy41hr53cDbbNeNo05MI461TpI9b_xdIv8EY,7288
+tunacode/utils/token_counter.py,sha256=dmFuqVz4ywGFdLfAi5Mg9bAGf8v87Ek-mHU-R3fsYjI,2711
+tunacode/utils/user_configuration.py,sha256=Ilz8dpGVJDBE2iLWHAPT0xR8D51VRKV3kIbsAz8Bboc,3275
+tunacode_cli-0.0.53.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.53.dist-info/METADATA,sha256=5vCcjz1MDQ2o3udvSQC2kmmNHdxbruvk2V5fqaZdhhI,10193
+tunacode_cli-0.0.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunacode_cli-0.0.53.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.53.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
+tunacode_cli-0.0.53.dist-info/RECORD,,

{tunacode_cli-0.0.50.dist-info → tunacode_cli-0.0.53.dist-info}/top_level.txt

@@ -1,2 +1 @@
-api
 tunacode

api/auth.py

@@ -1,13 +0,0 @@
-import jwt
-
-
-def authenticate(username, password):
-    # TODO: Add password hashing
-    if username == "admin" and password == "admin":
-        return generate_token(username)
-    return None
-
-
-def generate_token(username):
-    # TODO: Add expiration
-    return jwt.encode({"user": username}, "secret")

api/users.py

@@ -1,8 +0,0 @@
-from .auth import authenticate
-
-
-class UserManager:
-    def login(self, username, password):
-        token = authenticate(username, password)
-        # TODO: Store session
-        return token

tunacode/core/recursive/__init__.py

@@ -1,18 +0,0 @@
-"""Module: tunacode.core.recursive
-
-Recursive task execution system for complex task decomposition and execution.
-"""
-
-from .aggregator import ResultAggregator
-from .budget import BudgetManager
-from .decomposer import TaskDecomposer
-from .executor import RecursiveTaskExecutor
-from .hierarchy import TaskHierarchy
-
-__all__ = [
-    "RecursiveTaskExecutor",
-    "TaskDecomposer",
-    "TaskHierarchy",
-    "BudgetManager",
-    "ResultAggregator",
-]

tunacode/core/recursive/aggregator.py

@@ -1,467 +0,0 @@
-"""Module: tunacode.core.recursive.aggregator
-
-Result aggregation and context management for recursive task execution.
-"""
-
-import json
-import logging
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-from typing import Any, Dict, List, Optional, Set
-
-from tunacode.core.state import StateManager
-
-logger = logging.getLogger(__name__)
-
-
-class AggregationStrategy(Enum):
-    """Strategies for aggregating results."""
-
-    CONCATENATE = "concatenate"  # Simple concatenation
-    STRUCTURED = "structured"  # Preserve task structure
-    SUMMARY = "summary"  # Generate summary
-    INTELLIGENT = "intelligent"  # Use agent to merge
-
-
-class ConflictResolution(Enum):
-    """Strategies for resolving conflicts in results."""
-
-    LATEST = "latest"  # Use most recent result
-    PRIORITY = "priority"  # Use highest priority result
-    MERGE = "merge"  # Attempt to merge
-    AGENT = "agent"  # Use agent to resolve
-
-
-@dataclass
-class TaskResult:
-    """Result from a single task execution."""
-
-    task_id: str
-    task_title: str
-    result_data: object
-    status: str  # completed, failed, partial
-    timestamp: datetime = field(default_factory=datetime.now)
-    error: Optional[str] = None
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class AggregatedResult:
-    """Aggregated result from multiple tasks."""
-
-    primary_result: object
-    task_results: List[TaskResult]
-    strategy_used: AggregationStrategy
-    conflicts_resolved: int = 0
-    partial_failures: List[str] = field(default_factory=list)
-    metadata: Dict[str, Any] = field(default_factory=dict)
-    aggregation_time: datetime = field(default_factory=datetime.now)
-
-
-@dataclass
-class ExecutionContext:
-    """Context information during execution."""
-
-    task_id: str
-    parent_context: Dict[str, Any]
-    local_context: Dict[str, Any]
-    files_accessed: Set[str] = field(default_factory=set)
-    tools_used: List[str] = field(default_factory=list)
-    key_findings: List[str] = field(default_factory=list)
-
-
-class ResultAggregator:
-    """Aggregates results from distributed subtask executions."""
-
-    def __init__(self, state_manager: StateManager):
-        """Initialize the ResultAggregator.
-
-        Args:
-            state_manager: StateManager for accessing agents
-        """
-        self.state_manager = state_manager
-        self._context_cache: Dict[str, ExecutionContext] = {}
-
-    async def aggregate_results(
-        self,
-        task_results: List[TaskResult],
-        parent_task: Optional[Dict[str, Any]] = None,
-        strategy: AggregationStrategy = AggregationStrategy.INTELLIGENT,
-    ) -> AggregatedResult:
-        """Aggregate results from multiple subtasks.
-
-        Args:
-            task_results: List of results from subtasks
-            parent_task: Optional parent task information
-            strategy: Aggregation strategy to use
-
-        Returns:
-            AggregatedResult with merged data
-        """
-        if not task_results:
-            return AggregatedResult(
-                primary_result="No results to aggregate", task_results=[], strategy_used=strategy
-            )
-
-        # Separate successful and failed results
-        successful_results = [r for r in task_results if r.status == "completed"]
-        failed_results = [r for r in task_results if r.status == "failed"]
-        partial_results = [r for r in task_results if r.status == "partial"]
-
-        # Handle complete failure
-        if not successful_results and not partial_results:
-            return AggregatedResult(
-                primary_result="All subtasks failed",
-                task_results=task_results,
-                strategy_used=strategy,
-                partial_failures=[r.task_id for r in failed_results],
-            )
-
-        # Apply aggregation strategy
-        if strategy == AggregationStrategy.CONCATENATE:
-            result = await self._aggregate_concatenate(successful_results + partial_results)
-        elif strategy == AggregationStrategy.STRUCTURED:
-            result = await self._aggregate_structured(
-                successful_results + partial_results, parent_task
-            )
-        elif strategy == AggregationStrategy.SUMMARY:
-            result = await self._aggregate_summary(
-                successful_results + partial_results, parent_task
-            )
-        elif strategy == AggregationStrategy.INTELLIGENT:
-            result = await self._aggregate_intelligent(
-                successful_results + partial_results, parent_task
-            )
-        else:
-            result = await self._aggregate_concatenate(successful_results + partial_results)
-
-        return AggregatedResult(
-            primary_result=result,
-            task_results=task_results,
-            strategy_used=strategy,
-            partial_failures=[r.task_id for r in failed_results],
-        )
-
-    async def _aggregate_concatenate(self, results: List[TaskResult]) -> str:
-        """Simple concatenation of results.
-
-        Args:
-            results: List of successful results
-
-        Returns:
-            Concatenated string result
-        """
-        parts = []
-        for i, result in enumerate(results):
-            parts.append(f"=== Task {i + 1}: {result.task_title} ===")
-            parts.append(str(result.result_data))
-            parts.append("")
-
-        return "\n".join(parts)
-
-    async def _aggregate_structured(
-        self, results: List[TaskResult], parent_task: Optional[Dict[str, Any]]
-    ) -> Dict[str, Any]:
-        """Create structured aggregation preserving task relationships.
-
-        Args:
-            results: List of successful results
-            parent_task: Parent task information
-
-        Returns:
-            Structured dictionary result
-        """
-        structured_result = {
-            "parent_task": parent_task.get("title") if parent_task else "Unknown",
-            "completed_subtasks": len([r for r in results if r.status == "completed"]),
-            "partial_subtasks": len([r for r in results if r.status == "partial"]),
-            "subtask_results": [],
-        }
-
-        for result in results:
-            structured_result["subtask_results"].append(
-                {
-                    "task_id": result.task_id,
-                    "title": result.task_title,
-                    "status": result.status,
-                    "result": result.result_data,
-                    "timestamp": result.timestamp.isoformat(),
-                }
-            )
-
-        return structured_result
-
-    async def _aggregate_summary(
-        self, results: List[TaskResult], parent_task: Optional[Dict[str, Any]]
-    ) -> str:
-        """Generate a summary of results.
-
-        Args:
-            results: List of successful results
-            parent_task: Parent task information
-
-        Returns:
-            Summary string
-        """
-        summary_parts = []
-
-        if parent_task:
-            summary_parts.append(f"Summary for: {parent_task.get('title', 'Unknown Task')}")
-            summary_parts.append("")
-
-        summary_parts.append(f"Completed {len(results)} subtasks:")
-        summary_parts.append("")
-
-        for i, result in enumerate(results):
-            # Extract key information from result
-            result_str = str(result.result_data)
-            preview = result_str[:200] + "..." if len(result_str) > 200 else result_str
-
-            summary_parts.append(f"{i + 1}. {result.task_title}")
-            summary_parts.append(f"   Status: {result.status}")
-            summary_parts.append(f"   Result: {preview}")
-            summary_parts.append("")
-
-        return "\n".join(summary_parts)
-
-    async def _aggregate_intelligent(
-        self, results: List[TaskResult], parent_task: Optional[Dict[str, Any]]
-    ) -> Any:
-        """Use agent to intelligently merge results.
-
-        Args:
-            results: List of successful results
-            parent_task: Parent task information
-
-        Returns:
-            Intelligently merged result
-        """
-        agent = self.state_manager.session.agents.get("main")
-        if not agent:
-            # Fallback to summary
-            return await self._aggregate_summary(results, parent_task)
-
-        # Prepare context for agent
-        context = {
-            "parent_task": parent_task.get("description") if parent_task else "Unknown",
-            "subtask_count": len(results),
-            "subtask_results": [],
-        }
-
-        for result in results:
-            context["subtask_results"].append(
-                {
-                    "title": result.task_title,
-                    "result": str(result.result_data)[:500],  # Limit size
-                }
-            )
-
-        merge_prompt = f"""Intelligently merge and synthesize these subtask results into a coherent response.
-
-Parent Task: {context["parent_task"]}
-
-Subtask Results:
-{json.dumps(context["subtask_results"], indent=2)}
-
-Instructions:
-1. Identify the key achievements from each subtask
-2. Synthesize findings into a unified response
-3. Highlight any important patterns or insights
-4. Present the result in a clear, actionable format
-
-Provide a comprehensive but concise synthesis that addresses the original task."""
-
-        try:
-            result = await agent.run(merge_prompt)
-            return result
-        except Exception as e:
-            logger.error(f"Agent-based aggregation failed: {str(e)}")
-            # Fallback to summary
-            return await self._aggregate_summary(results, parent_task)
-
-    def create_context(
-        self, task_id: str, parent_context: Optional[Dict[str, Any]] = None
-    ) -> ExecutionContext:
-        """Create an execution context for a task.
-
-        Args:
-            task_id: Task identifier
-            parent_context: Optional parent context to inherit
-
-        Returns:
-            New execution context
-        """
-        context = ExecutionContext(
-            task_id=task_id, parent_context=parent_context or {}, local_context={}
-        )
-
-        self._context_cache[task_id] = context
-        return context
-
-    def get_context(self, task_id: str) -> Optional[ExecutionContext]:
-        """Get execution context for a task.
-
-        Args:
-            task_id: Task identifier
-
-        Returns:
-            Execution context or None
-        """
-        return self._context_cache.get(task_id)
-
-    def update_context(
-        self,
-        task_id: str,
-        updates: Dict[str, Any],
-        files: Optional[Set[str]] = None,
-        tools: Optional[List[str]] = None,
-        findings: Optional[List[str]] = None,
-    ) -> None:
-        """Update execution context for a task.
-
-        Args:
-            task_id: Task identifier
-            updates: Context updates
-            files: Files accessed
-            tools: Tools used
-            findings: Key findings
-        """
-        context = self._context_cache.get(task_id)
-        if not context:
-            logger.warning(f"No context found for task {task_id}")
-            return
-
-        context.local_context.update(updates)
-
-        if files:
-            context.files_accessed.update(files)
-        if tools:
-            context.tools_used.extend(tools)
-        if findings:
-            context.key_findings.extend(findings)
-
-    def synthesize_contexts(self, task_ids: List[str]) -> Dict[str, Any]:
-        """Synthesize contexts from multiple tasks.
-
-        Args:
-            task_ids: List of task IDs
-
-        Returns:
-            Synthesized context dictionary
-        """
-        synthesized = {
-            "files_accessed": set(),
-            "tools_used": [],
-            "key_findings": [],
-            "combined_context": {},
-        }
-
-        for task_id in task_ids:
-            context = self._context_cache.get(task_id)
-            if context:
-                synthesized["files_accessed"].update(context.files_accessed)
-                synthesized["tools_used"].extend(context.tools_used)
-                synthesized["key_findings"].extend(context.key_findings)
-                synthesized["combined_context"].update(context.local_context)
-
-        # Convert set to list for JSON serialization
-        synthesized["files_accessed"] = list(synthesized["files_accessed"])
-
-        # Remove duplicates from tools while preserving order
-        seen = set()
-        unique_tools = []
-        for tool in synthesized["tools_used"]:
-            if tool not in seen:
-                seen.add(tool)
-                unique_tools.append(tool)
-        synthesized["tools_used"] = unique_tools
-
-        return synthesized
-
-    async def resolve_conflicts(
-        self,
-        conflicting_results: List[TaskResult],
-        strategy: ConflictResolution = ConflictResolution.AGENT,
-    ) -> TaskResult:
-        """Resolve conflicts between contradictory results.
-
-        Args:
-            conflicting_results: List of conflicting results
-            strategy: Resolution strategy
-
-        Returns:
-            Single resolved result
-        """
-        if not conflicting_results:
-            raise ValueError("No results to resolve conflicts for")
-
-        if len(conflicting_results) == 1:
-            return conflicting_results[0]
-
-        if strategy == ConflictResolution.LATEST:
-            # Return most recent result
-            return max(conflicting_results, key=lambda r: r.timestamp)
-
-        elif strategy == ConflictResolution.PRIORITY:
-            # Use metadata priority if available
-            def get_priority(result: TaskResult) -> int:
-                return result.metadata.get("priority", 0)
-
-            return max(conflicting_results, key=get_priority)
-
-        elif strategy == ConflictResolution.MERGE:
-            # Simple merge attempt
-            merged_data = {}
-            for result in conflicting_results:
-                if isinstance(result.result_data, dict):
-                    merged_data.update(result.result_data)
-                else:
-                    # Can't merge non-dict results
-                    return conflicting_results[-1]
-
-            return TaskResult(
-                task_id="merged",
-                task_title="Merged Result",
-                result_data=merged_data,
-                status="completed",
-            )
-
-        elif strategy == ConflictResolution.AGENT:
-            # Use agent to resolve
-            agent = self.state_manager.session.agents.get("main")
-            if not agent:
-                # Fallback to latest
-                return max(conflicting_results, key=lambda r: r.timestamp)
-
-            conflict_data = []
-            for result in conflicting_results:
-                conflict_data.append(
-                    {
-                        "task": result.task_title,
-                        "result": str(result.result_data)[:300],
-                        "timestamp": result.timestamp.isoformat(),
-                    }
-                )
-
-            resolution_prompt = f"""Resolve conflicts between these task results:
-
-{json.dumps(conflict_data, indent=2)}
-
-Analyze the differences and provide a single, coherent result that best represents the correct outcome."""
-
-            try:
-                resolved = await agent.run(resolution_prompt)
-                return TaskResult(
-                    task_id="resolved",
-                    task_title="Conflict Resolved",
-                    result_data=resolved,
-                    status="completed",
-                )
-            except Exception as e:
-                logger.error(f"Agent conflict resolution failed: {str(e)}")
-                # Fallback to latest
-                return max(conflicting_results, key=lambda r: r.timestamp)
-
-        # Default to latest
-        return max(conflicting_results, key=lambda r: r.timestamp)