claude-task-master 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

claude_task_master/core/orchestrator.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 import subprocess
 import time
+from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
 from . import console
@@ -34,9 +35,11 @@ from .workflow_stages import WorkflowStageHandler
 
 if TYPE_CHECKING:
     from ..github import GitHubClient
+    from ..mailbox import MailboxStorage, MessageMerger
     from ..webhooks import WebhookClient
     from ..webhooks.events import EventType
     from .logger import TaskLogger
+    from .plan_updater import PlanUpdater
 
 logger = logging.getLogger(__name__)
 
@@ -223,6 +226,9 @@ class WorkLoopOrchestrator:
         self._stage_handler: WorkflowStageHandler | None = None
         self._pr_context: PRContextManager | None = None
         self._webhook_emitter: WebhookEmitter | None = None
+        self._mailbox_storage: MailboxStorage | None = None
+        self._message_merger: MessageMerger | None = None
+        self._plan_updater: PlanUpdater | None = None
 
     @property
     def github_client(self) -> GitHubClient:
@@ -269,6 +275,7 @@ class WorkLoopOrchestrator:
                 state_manager=self.state_manager,
                 github_client=self.github_client,
                 pr_context=self.pr_context,
+                webhook_emitter=self.webhook_emitter,
             )
         return self._stage_handler
 
@@ -287,6 +294,41 @@ class WorkLoopOrchestrator:
             self._webhook_emitter = WebhookEmitter(self._webhook_client, run_id)
         return self._webhook_emitter
 
+    @property
+    def mailbox_storage(self) -> MailboxStorage:
+        """Get or lazily initialize mailbox storage."""
+        if self._mailbox_storage is None:
+            from ..mailbox import MailboxStorage
+
+            self._mailbox_storage = MailboxStorage(self.state_manager.state_dir)
+            logger.debug(
+                "Mailbox storage initialized: path=%s",
+                self._mailbox_storage.storage_path,
+            )
+        return self._mailbox_storage
+
+    @property
+    def message_merger(self) -> MessageMerger:
+        """Get or lazily initialize message merger."""
+        if self._message_merger is None:
+            from ..mailbox import MessageMerger
+
+            self._message_merger = MessageMerger()
+        return self._message_merger
+
+    @property
+    def plan_updater(self) -> PlanUpdater:
+        """Get or lazily initialize plan updater."""
+        if self._plan_updater is None:
+            from .plan_updater import PlanUpdater
+
+            self._plan_updater = PlanUpdater(
+                agent=self.agent,
+                state_manager=self.state_manager,
+                logger=self.logger,
+            )
+        return self._plan_updater
+
     def _get_total_tasks(self, state: TaskState) -> int:
         """Get total number of tasks from the plan.
 
@@ -412,6 +454,272 @@ class WorkLoopOrchestrator:
             auto_merged=state.options.auto_merge,
         )
 
+    def _check_and_process_mailbox(self, state: TaskState) -> bool:
+        """Check mailbox and update plan if messages exist.
+
+        This method is called after each task completion to check for
+        messages from other instances or external systems. If messages
+        are found, they are merged and used to update the plan.
+
+        The last_mailbox_check timestamp is always updated regardless of
+        whether messages were found, to track when the mailbox was last
+        monitored.
+
+        Args:
+            state: Current task state.
+
+        Returns:
+            True if plan was updated, False otherwise.
+        """
+        logger.debug(
+            "Mailbox check starting: task_index=%d, session_count=%d",
+            state.current_task_index,
+            state.session_count,
+        )
+
+        # Check if there are any messages in the mailbox
+        message_count = self.mailbox_storage.count()
+        if message_count == 0:
+            check_time = datetime.now()
+            logger.debug(
+                "Mailbox check complete: no messages, timestamp=%s",
+                check_time.isoformat(),
+            )
+            # Always update the timestamp to track when mailbox was checked
+            state.last_mailbox_check = check_time
+            self.state_manager.save_state(state)
+            return False
+
+        # Log that we're processing messages
+        logger.info(
+            "Mailbox check: found %d message(s) to process",
+            message_count,
+        )
+        console.info(f"Found {message_count} message(s) in mailbox - processing...")
+
+        # Get and clear messages atomically
+        messages = self.mailbox_storage.get_and_clear()
+        if not messages:
+            # Race condition - messages were cleared by another process
+            logger.warning(
+                "Mailbox race condition: messages disappeared between count (%d) and get",
+                message_count,
+            )
+            return False
+
+        # Log details of each message being processed
+        for msg in messages:
+            logger.info(
+                "Mailbox message: id=%s, sender=%s, priority=%s, timestamp=%s, content_length=%d",
+                msg.id,
+                msg.sender,
+                msg.priority.name if hasattr(msg.priority, "name") else msg.priority,
+                msg.timestamp.isoformat() if msg.timestamp else "none",
+                len(msg.content),
+            )
+
+        # Merge messages into a single change request
+        logger.debug(
+            "Merging %d mailbox messages from senders: %s",
+            len(messages),
+            [msg.sender for msg in messages],
+        )
+        try:
+            merged_content = self.message_merger.merge(messages)
+            logger.info(
+                "Mailbox messages merged successfully: total_length=%d, preview=%s...",
+                len(merged_content),
+                merged_content[:100].replace("\n", " "),
+            )
+        except ValueError as e:
+            logger.error(
+                "Failed to merge mailbox messages: error=%s, message_count=%d",
+                e,
+                len(messages),
+            )
+            console.warning(f"Failed to merge mailbox messages: {e}")
+            return False
+
+        # Update the plan with the merged content
+        logger.debug("Starting plan update from mailbox messages")
+        try:
+            # Capture task count before update for diff calculation
+            total_tasks_before = self._get_total_tasks(state)
+
+            console.info("Updating plan based on mailbox messages...")
+            result = self.plan_updater.update_plan(merged_content)
+
+            check_time = datetime.now()
+            if result.get("changes_made"):
+                console.success("Plan updated based on mailbox messages")
+                logger.info(
+                    "Plan updated from mailbox: changes_made=True, "
+                    "message_count=%d, senders=%s, timestamp=%s",
+                    len(messages),
+                    [msg.sender for msg in messages],
+                    check_time.isoformat(),
+                )
+
+                # Update state to record the mailbox check
+                state.last_mailbox_check = check_time
+                self.state_manager.save_state(state)
+                logger.debug(
+                    "State saved with mailbox check timestamp: %s",
+                    check_time.isoformat(),
+                )
+
+                # Emit plan.updated webhook event
+                # Get task counts for the updated plan
+                updated_total_tasks = self._get_total_tasks(state)
+                updated_completed_tasks = self._get_completed_tasks(state)
+
+                # Calculate task diff
+                task_diff = updated_total_tasks - total_tasks_before
+                tasks_added = max(0, task_diff)
+                tasks_removed = max(0, -task_diff)
+
+                self.webhook_emitter.emit(
+                    "plan.updated",
+                    update_source="mailbox",
+                    message=merged_content[:500]
+                    if merged_content
+                    else None,  # Truncate long messages
+                    total_tasks=updated_total_tasks,
+                    completed_tasks=updated_completed_tasks,
+                    tasks_added=tasks_added,
+                    tasks_modified=None,  # TODO: Calculate from plan diff (requires content comparison)
+                    tasks_removed=tasks_removed,
+                )
+
+                return True
+            else:
+                console.info("Mailbox messages processed - no plan changes needed")
+                logger.info(
+                    "Plan not modified from mailbox: message_count=%d, senders=%s, timestamp=%s",
+                    len(messages),
+                    [msg.sender for msg in messages],
+                    check_time.isoformat(),
+                )
+
+                # Still record that we checked
+                state.last_mailbox_check = check_time
+                self.state_manager.save_state(state)
+                logger.debug(
+                    "State saved with mailbox check timestamp: %s",
+                    check_time.isoformat(),
+                )
+
+                # Emit plan.updated with no changes (still useful for tracking)
+                current_total_tasks = self._get_total_tasks(state)
+                current_completed_tasks = self._get_completed_tasks(state)
+
+                self.webhook_emitter.emit(
+                    "plan.updated",
+                    update_source="mailbox",
+                    message=merged_content[:500] if merged_content else None,  # Truncate
+                    total_tasks=current_total_tasks,
+                    completed_tasks=current_completed_tasks,
+                    tasks_added=0,
+                    tasks_modified=0,
+                    tasks_removed=0,
+                )
+
+                return False
+
+        except ValueError as e:
+            # No plan exists - can't update
+            logger.error(
+                "Cannot update plan from mailbox: no plan exists, error=%s, message_count=%d",
+                e,
+                len(messages),
+            )
+            console.warning(f"Cannot update plan: {e}")
+            return False
+        except Exception as e:
+            # Other errors during plan update
+            logger.error(
+                "Error updating plan from mailbox: error=%s, type=%s, message_count=%d",
+                e,
+                type(e).__name__,
+                len(messages),
+            )
+            console.warning(f"Error updating plan from mailbox: {e}")
+            return False
+
+    def _emit_status_changed(
+        self,
+        previous_status: str,
+        new_status: str,
+        state: TaskState,
+        reason: str | None = None,
+    ) -> None:
+        """Emit a status.changed webhook event when status transitions.
+
+        Args:
+            previous_status: The status before the change.
+            new_status: The status after the change.
+            state: Current task state.
+            reason: Optional reason for the status change.
+        """
+        # Only emit if status actually changed
+        if previous_status == new_status:
+            return
+
+        self.webhook_emitter.emit(
+            "status.changed",
+            previous_status=previous_status,
+            new_status=new_status,
+            reason=reason,
+            task_index=state.current_task_index,
+            session_number=state.session_count,
+        )
+
+    def _emit_run_completed(
+        self,
+        state: TaskState,
+        exit_code: int,
+        result: str,
+        run_start_time: float,
+        error_message: str | None = None,
+    ) -> None:
+        """Emit a run.completed webhook event.
+
+        Args:
+            state: Current task state.
+            exit_code: Exit code (0=success, 1=blocked, 2=interrupted).
+            result: Outcome string ("success", "blocked", "failed", "interrupted").
+            run_start_time: Time when the run started (time.time() value).
+            error_message: Error message if run failed (optional).
+        """
+        # Get goal from state manager
+        goal = ""
+        try:
+            goal = self.state_manager.load_goal()
+        except Exception:
+            pass
+
+        # Get task counts
+        total_tasks = self._get_total_tasks(state)
+        completed_tasks = self._get_completed_tasks(state)
+
+        # Calculate duration
+        duration_seconds = time.time() - run_start_time if run_start_time > 0 else None
+
+        self.webhook_emitter.emit(
+            "run.completed",
+            goal=goal,
+            result=result,
+            exit_code=exit_code,
+            total_tasks=total_tasks,
+            completed_tasks=completed_tasks,
+            total_sessions=state.session_count,
+            duration_seconds=duration_seconds,
+            prs_created=0,  # TODO: Track PR counts in state
+            prs_merged=0,  # TODO: Track PR counts in state
+            final_status=state.status,
+            error_message=error_message,
+        )
+
     def run(self) -> int:
         """Run the main work loop until completion or blocked.
 
@@ -420,6 +728,9 @@ class WorkLoopOrchestrator:
             1: Blocked/Failed - max sessions reached or error.
             2: Paused - user interrupted.
         """
+        # Track run start time for duration calculation
+        run_start_time = time.time()
+
         # Load state with recovery
         try:
             state = self.state_manager.load_state()
@@ -437,8 +748,34 @@ class WorkLoopOrchestrator:
             console.warning(
                 MaxSessionsReachedError(state.options.max_sessions, state.session_count).message
             )
+            self._emit_run_completed(state, 1, "blocked", run_start_time, "Max sessions reached")
             return 1
 
+        # Emit run.started webhook event
+        # Determine if this is a resumed run (session_count > 0 means we've run before)
+        is_resumed = state.session_count > 0
+        pr_mode = "per-task" if state.options.pr_per_task else "per-group"
+
+        # Load goal from state manager (stored in goal.txt)
+        goal = ""
+        try:
+            goal = self.state_manager.load_goal()
+        except Exception:
+            pass  # Goal is optional for webhook
+
+        # Get working directory (parent of state_dir which is .claude-task-master/)
+        working_directory = str(self.state_manager.state_dir.parent)
+
+        self.webhook_emitter.emit(
+            "run.started",
+            goal=goal,
+            working_directory=working_directory,
+            max_sessions=state.options.max_sessions,
+            auto_merge=state.options.auto_merge,
+            pr_mode=pr_mode,
+            resumed=is_resumed,
+        )
+
         # Setup signal handlers and key listener
         register_handlers()
         reset_shutdown()
@@ -451,12 +788,15 @@ class WorkLoopOrchestrator:
             console.newline()
             console.warning(f"{reason} - pausing...")
             self.tracker.end_session(outcome="cancelled")
+            previous_status = state.status
             state.status = "paused"
+            self._emit_status_changed(previous_status, "paused", state, reason)
             self.state_manager.save_state(state)
             self.state_manager.create_state_backup()
             console.newline()
             console.info(self.tracker.get_cost_report())
             console.info("Use 'claudetm resume' to continue")
+            self._emit_run_completed(state, 2, "interrupted", run_start_time, reason)
             return 2
 
         try:
@@ -476,11 +816,14 @@ class WorkLoopOrchestrator:
                 should_abort, abort_reason = self.tracker.should_abort()
                 if should_abort:
                     console.warning(f"Execution issue: {abort_reason}")
+                    previous_status = state.status
                     state.status = "blocked"
+                    self._emit_status_changed(previous_status, "blocked", state, abort_reason)
                     self.state_manager.save_state(state)
                     stop_listening()
                     unregister_handlers()
                     console.info(self.tracker.get_cost_report())
+                    self._emit_run_completed(state, 1, "blocked", run_start_time, abort_reason)
                     return 1
 
                 # Run workflow cycle
@@ -489,6 +832,9 @@ class WorkLoopOrchestrator:
                     stop_listening()
                     unregister_handlers()
                     console.info(self.tracker.get_cost_report())
+                    # Determine result string based on exit code
+                    result_str = "success" if result == 0 else "blocked"
+                    self._emit_run_completed(state, result, result_str, run_start_time)
                     return result
 
                 # Debug: check completion after each cycle
@@ -501,11 +847,18 @@ class WorkLoopOrchestrator:
                 # Check session limit
                 if state.options.max_sessions and state.session_count >= state.options.max_sessions:
                     console.warning(f"Max sessions ({state.options.max_sessions}) reached")
+                    previous_status = state.status
                     state.status = "blocked"
+                    self._emit_status_changed(
+                        previous_status, "blocked", state, "Max sessions reached"
+                    )
                     self.state_manager.save_state(state)
                     stop_listening()
                     unregister_handlers()
                     console.info(self.tracker.get_cost_report())
+                    self._emit_run_completed(
+                        state, 1, "blocked", run_start_time, "Max sessions reached"
+                    )
                     return 1
 
             # All complete - verify with retry loop for fixes
@@ -522,45 +875,68 @@ class WorkLoopOrchestrator:
                 if verification["success"]:
                     # Success! Checkout to main and cleanup
                     self._checkout_to_main()
+                    previous_status = state.status
                     state.status = "success"
+                    self._emit_status_changed(
+                        previous_status, "success", state, "All tasks completed successfully"
+                    )
                     self.state_manager.save_state(state)
                     self.state_manager.cleanup_on_success(state.run_id)
                     console.success("All tasks completed successfully!")
                     console.info(self.tracker.get_cost_report())
+                    self._emit_run_completed(state, 0, "success", run_start_time)
                     return 0
 
                 # Verification failed
                 console.warning("Success criteria verification failed")
 
                 if fix_attempt >= max_fix_attempts:
-                    # Max attempts reached - checkout to main and fail
+                    # Max attempts reached - stay on branch for easier resume
                     console.error(f"Max fix attempts ({max_fix_attempts}) reached")
-                    self._checkout_to_main()
+                    previous_status = state.status
                     state.status = "blocked"
+                    self._emit_status_changed(
+                        previous_status, "blocked", state, "Max fix attempts reached"
+                    )
                     self.state_manager.save_state(state)
                     console.info(self.tracker.get_cost_report())
+                    self._emit_run_completed(
+                        state, 1, "blocked", run_start_time, "Max fix attempts reached"
+                    )
                     return 1
 
                 # Attempt to fix
                 console.info(f"Attempting fix {fix_attempt + 1}/{max_fix_attempts}...")
 
                 if not self._run_verification_fix(verification["details"], state):
-                    # Fix failed - checkout to main and fail
+                    # Fix failed - stay on branch for easier resume
                     console.error("Fix attempt failed")
-                    self._checkout_to_main()
+                    previous_status = state.status
                     state.status = "blocked"
+                    self._emit_status_changed(
+                        previous_status, "blocked", state, "Verification fix failed"
+                    )
                     self.state_manager.save_state(state)
                     console.info(self.tracker.get_cost_report())
+                    self._emit_run_completed(
+                        state, 1, "failed", run_start_time, "Verification fix failed"
+                    )
                     return 1
 
                 # Wait for PR to be created and merge it
                 if not self._wait_for_fix_pr_merge(state):
-                    # PR merge failed - checkout to main and fail
+                    # PR merge failed - stay on branch for easier resume
                     console.error("Fix PR merge failed")
-                    self._checkout_to_main()
+                    previous_status = state.status
                     state.status = "blocked"
+                    self._emit_status_changed(
+                        previous_status, "blocked", state, "Fix PR merge failed"
+                    )
                     self.state_manager.save_state(state)
                     console.info(self.tracker.get_cost_report())
+                    self._emit_run_completed(
+                        state, 1, "blocked", run_start_time, "Fix PR merge failed"
+                    )
                     return 1
 
                 # PR merged - increment and retry verification
@@ -568,10 +944,17 @@ class WorkLoopOrchestrator:
                 console.info("Fix PR merged - re-verifying...")
 
             # Should not reach here, but handle it gracefully
-            self._checkout_to_main()
+            # Stay on branch for easier resume
+            previous_status = state.status
             state.status = "blocked"
+            self._emit_status_changed(
+                previous_status, "blocked", state, "Unexpected exit from verification loop"
+            )
             self.state_manager.save_state(state)
             console.info(self.tracker.get_cost_report())
+            self._emit_run_completed(
+                state, 1, "blocked", run_start_time, "Unexpected exit from verification loop"
+            )
             return 1
 
         except KeyboardInterrupt:
@@ -580,23 +963,30 @@ class WorkLoopOrchestrator:
             stop_listening()
             unregister_handlers()
             console.error(f"Orchestrator error: {e.message}")
+            previous_status = state.status
             state.status = "failed"
+            self._emit_status_changed(previous_status, "failed", state, e.message)
             try:
-                self._checkout_to_main()
+                # Don't checkout to main on error - stay on branch for easier resume
                 self.state_manager.save_state(state)
             except Exception:
                 pass  # Best effort - state save failed but we still return error
+            self._emit_run_completed(state, 1, "failed", run_start_time, e.message)
             return 1
         except Exception as e:
             stop_listening()
             unregister_handlers()
             console.error(f"Unexpected error: {type(e).__name__}: {e}")
+            previous_status = state.status
             state.status = "failed"
+            error_message = f"{type(e).__name__}: {e}"
+            self._emit_status_changed(previous_status, "failed", state, error_message)
             try:
-                self._checkout_to_main()
+                # Don't checkout to main on error - stay on branch for easier resume
                 self.state_manager.save_state(state)
             except Exception:
                 pass  # Best effort - state save failed but we still return error
+            self._emit_run_completed(state, 1, "failed", run_start_time, error_message)
             return 1
 
     def _run_workflow_cycle(self, state: TaskState) -> int | None:
@@ -646,24 +1036,38 @@ class WorkLoopOrchestrator:
 
         except NoPlanFoundError as e:
             console.error(e.message)
+            previous_status = state.status
             state.status = "failed"
+            self._emit_status_changed(previous_status, "failed", state, e.message)
             self.state_manager.save_state(state)
             return 1
         except NoTasksFoundError:
             return None  # Continue to completion check
         except ContentFilterError as e:
             console.error(f"Content filter: {e.message}")
+            previous_status = state.status
             state.status = "blocked"
+            self._emit_status_changed(
+                previous_status, "blocked", state, f"Content filter: {e.message}"
+            )
             self.state_manager.save_state(state)
             return 1
         except CircuitBreakerError as e:
             console.warning(f"Circuit breaker: {e.message}")
+            previous_status = state.status
             state.status = "blocked"
+            self._emit_status_changed(
+                previous_status, "blocked", state, f"Circuit breaker: {e.message}"
+            )
             self.state_manager.save_state(state)
             return 1
         except ConsecutiveFailuresError as e:
             console.error(f"Consecutive failures: {e.message}")
+            previous_status = state.status
             state.status = "blocked"
+            self._emit_status_changed(
+                previous_status, "blocked", state, f"Consecutive failures: {e.message}"
+            )
             self.state_manager.save_state(state)
             return 1
         except AgentError as e:
@@ -776,6 +1180,25 @@ class WorkLoopOrchestrator:
             branch=current_branch,
         )
 
+        # Check mailbox for any messages after task completion
+        # If messages exist, merge them and update the plan
+        logger.debug(
+            "Checking mailbox after task %d completion",
+            state.current_task_index,
+        )
+        plan_updated = self._check_and_process_mailbox(state)
+        if plan_updated:
+            # Plan was updated - need to refresh total_tasks count
+            # The task list may have changed
+            old_total = total_tasks
+            total_tasks = self._get_total_tasks(state)
+            logger.info(
+                "Plan updated from mailbox: old_total_tasks=%d, new_total_tasks=%d",
+                old_total,
+                total_tasks,
+            )
+            console.detail(f"Plan updated - new total tasks: {total_tasks}")
+
         # Determine if we should trigger PR workflow or continue to next task
         # Two modes: pr_per_task=True (one PR per task) or grouped mode (one PR per group)
         if state.options.pr_per_task:

claude_task_master/core/parallel.py

@@ -13,7 +13,7 @@ from collections.abc import Callable
 from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Generic, TypeVar
+from typing import Any, TypeVar
 
 from .circuit_breaker import CircuitBreaker, CircuitBreakerConfig, get_circuit_breaker
 
@@ -31,7 +31,7 @@ class TaskStatus(Enum):
 
 
 @dataclass
-class TaskResult(Generic[T]):
+class TaskResult[T]:
     """Result of a parallel task execution."""
 
     task_id: str
@@ -82,7 +82,7 @@ class ParallelExecutorConfig:
 
 
 @dataclass
-class ParallelTask(Generic[T]):
+class ParallelTask[T]:
     """A task to be executed in parallel."""
 
     task_id: str
@@ -406,7 +406,7 @@ class AsyncParallelExecutor:
                     task_result = await asyncio.wait_for(coro, timeout=self.timeout)
                     result.result = task_result
                     result.status = TaskStatus.COMPLETED
-                except asyncio.TimeoutError as e:
+                except TimeoutError as e:
                     result.error = e
                     result.status = TaskStatus.FAILED
                 except Exception as e: