* feat: add backend task event protocol * fix: harden spec_runner project detection * feat: parse task events and track sequences * feat: add xstate task machine * feat: wire task events into state manager * refactor: centralize status handling in state manager * feat: hydrate task state and propagate reviewReason * auto-claude: subtask-1-1 - Create card_data.txt file with literal string 'card data' Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com> * fix: skip stuck detection for QA phases to prevent race conditions Added qa_review and qa_fixing to the stuck detection skip list in both TaskCard.tsx and useTaskDetail.ts. When the process exits unexpectedly during QA phases, XState handles transitioning to error state. Skipping stuck detection for these phases avoids race conditions where the stuck check fires before the status update IPC reaches the renderer. Also added unit tests for task-machine (35 tests) and task-state-manager (20 tests), plus XSTATE_MIGRATION_SUMMARY.md documenting the migration. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: use XState as source of truth instead of stale cache - Add getCurrentState() and isInPlanReview() methods to TaskStateManager - Fix TASK_START handler to check XState actor state before falling back to task data - Fix handleManualStatusChange to use XState state for determining correct event - Prevents wrong event being sent when plan approval happens with stale cached data - Add debug logging throughout state transitions for troubleshooting The root cause was that when approving a plan, the UI called startTask() which used cached task data (3-second TTL) to determine which XState event to send. If the cache was stale, it would send USER_RESUMED instead of PLAN_APPROVED, causing the task to transition incorrectly. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: prevent plan updates from overwriting XState-controlled status When TASK_PROGRESS events arrived with stale plan data containing status: 'in_progress', updateTaskFromPlan was overwriting the correct XState-set status (e.g., 'ai_review'), causing tasks to jump back to the wrong Kanban column. XState is now the sole source of truth for task status. Plan updates only update subtasks, title, and other non-status fields. Status changes only come through TASK_STATUS_CHANGE events emitted by XState. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: remove #1585 code from PR Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: ruff lint - remove unnecessary string annotation Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: biome lint and ruff format fixes - Wrap case 'in_progress' block with braces in task-state-manager.ts - Apply ruff format to 5 Python files Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: resolve flaky subprocess-spawn test on Windows CI The 'should track running tasks' test was failing intermittently on Windows CI because both tasks share the same mockProcess, and the timing of exit event handlers could vary between environments. Changes: - Emit exit events twice to ensure both handlers receive them - Use Promise.allSettled to wait for both tasks - Add 100ms delay for event handlers to complete on slower CI Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: address PR #1575 review findings and stuck detection false positives - Fix dual status emission in worktree handlers (#1, HIGH): route merge/discard status changes through TaskStateManager instead of direct IPC emission. Add human_review case to handleManualStatusChange. - Extract duplicate phaseMap to shared XSTATE_TO_PHASE constant (#6, LOW) - Add --force flag in spec_runner.py when chaining to run.py after auto-approved specs to prevent BUILD BLOCKED hash mismatch errors - Guard duplicate CODING_STARTED emission in coder.py (#8, MEDIUM): skip second emit when just_transitioned_from_planning is True - Simplify stuck detection to 60s catastrophic-only check: XState handles all normal process-exit transitions via PROCESS_EXITED events. Remove phase-skip logic, visibility handler, and 5s/30s timers. - Record task activity on status changes and log events (not just execution progress) to prevent false positive stuck detection - Add tests for activity recording and human_review manual status change Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(lint): ruff format spec_runner.py long lines Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix(test): resolve flaky subprocess-spawn test on Windows CI Wait for spawn promises to fully resolve before emitting exit events, ensuring exit handlers are attached. A single setImmediate was insufficient on Windows CI where async operations (getAPIProfileEnv, getRecoveryCoordinator) between addProcess and .on('exit') take longer. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: address PR review findings for XState refactor - CMT-001 [HIGH]: Add 'queue' and 'queued' status mappings to statusMap in project-store.ts to prevent task regression from queue to backlog when loading from disk - NEW-003 [MEDIUM]: Integrate clearAllTasks() into TASK_LIST handler's forceRefresh path and update documentation to reflect actual usage - CMT-003 [MEDIUM]: Change fail-open to fail-closed pattern in spec_runner.py - default require_review=True when JSON parsing fails Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * fix: address security and quality findings from PR review Security fixes: - NEW-006 [HIGH]: Add path traversal protection in TASK_CREATE and TASK_UPDATE image handlers using path.basename() sanitization and resolved path validation - NEW-005 [MEDIUM]: Add MIME type validation against allowlist in TASK_CREATE and TASK_UPDATE, consistent with TASK_REVIEW Quality fixes: - NEW-004 [LOW]: Add debug logging when context not found during XState state transitions to aid debugging - NEW-REVIEW-003 [MEDIUM]: Preserve lastSequenceByTask during clearAllTasks() to prevent duplicate event processing if backend events arrive during refresh window Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * test: update clearAllTasks test to expect preserved sequence tracking The test was expecting sequences to be cleared after clearAllTasks(), but the implementation was changed to preserve lastSequenceByTask to prevent duplicate event processing during the refresh window. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Haiku 4.5 <noreply@anthropic.com> Co-authored-by: AndyMik90 <andre@mikalsenutvikling.no> Co-authored-by: Andy <119136210+AndyMik90@users.noreply.github.com>
This commit is contained in:
kaigler
+747
-747
File diff suppressed because it is too large
Load Diff
+183
-183
@@ -1,183 +1,183 @@
|
||||
"""
|
||||
Planner Agent Module
|
||||
====================
|
||||
|
||||
Handles follow-up planner sessions for adding new subtasks to completed specs.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
from core.client import create_client
|
||||
from phase_config import get_phase_model, get_phase_thinking_budget
|
||||
from phase_event import ExecutionPhase, emit_phase
|
||||
from task_logger import (
|
||||
LogPhase,
|
||||
get_task_logger,
|
||||
)
|
||||
from ui import (
|
||||
BuildState,
|
||||
Icons,
|
||||
StatusManager,
|
||||
bold,
|
||||
box,
|
||||
highlight,
|
||||
icon,
|
||||
muted,
|
||||
print_status,
|
||||
)
|
||||
|
||||
from .session import run_agent_session
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def run_followup_planner(
|
||||
project_dir: Path,
|
||||
spec_dir: Path,
|
||||
model: str,
|
||||
verbose: bool = False,
|
||||
) -> bool:
|
||||
"""
|
||||
Run the follow-up planner to add new subtasks to a completed spec.
|
||||
|
||||
This is a simplified version of run_autonomous_agent that:
|
||||
1. Creates a client
|
||||
2. Loads the followup planner prompt
|
||||
3. Runs a single planning session
|
||||
4. Returns after the plan is updated (doesn't enter coding loop)
|
||||
|
||||
The planner agent will:
|
||||
- Read FOLLOWUP_REQUEST.md for the new task
|
||||
- Read the existing implementation_plan.json
|
||||
- Add new phase(s) with pending subtasks
|
||||
- Update the plan status back to in_progress
|
||||
|
||||
Args:
|
||||
project_dir: Root directory for the project
|
||||
spec_dir: Directory containing the completed spec
|
||||
model: Claude model to use
|
||||
verbose: Whether to show detailed output
|
||||
|
||||
Returns:
|
||||
bool: True if planning completed successfully
|
||||
"""
|
||||
from implementation_plan import ImplementationPlan
|
||||
from prompts import get_followup_planner_prompt
|
||||
|
||||
# Initialize status manager for ccstatusline
|
||||
status_manager = StatusManager(project_dir)
|
||||
status_manager.set_active(spec_dir.name, BuildState.PLANNING)
|
||||
emit_phase(ExecutionPhase.PLANNING, "Follow-up planning")
|
||||
|
||||
# Initialize task logger for persistent logging
|
||||
task_logger = get_task_logger(spec_dir)
|
||||
|
||||
# Show header
|
||||
content = [
|
||||
bold(f"{icon(Icons.GEAR)} FOLLOW-UP PLANNER SESSION"),
|
||||
"",
|
||||
f"Spec: {highlight(spec_dir.name)}",
|
||||
muted("Adding follow-up work to completed spec."),
|
||||
"",
|
||||
muted("The agent will read your FOLLOWUP_REQUEST.md and add new subtasks."),
|
||||
]
|
||||
print()
|
||||
print(box(content, width=70, style="heavy"))
|
||||
print()
|
||||
|
||||
# Start planning phase in task logger
|
||||
if task_logger:
|
||||
task_logger.start_phase(LogPhase.PLANNING, "Starting follow-up planning...")
|
||||
task_logger.set_session(1)
|
||||
|
||||
# Create client with phase-specific model and thinking budget
|
||||
# Respects task_metadata.json configuration when no CLI override
|
||||
planning_model = get_phase_model(spec_dir, "planning", model)
|
||||
planning_thinking_budget = get_phase_thinking_budget(spec_dir, "planning")
|
||||
client = create_client(
|
||||
project_dir,
|
||||
spec_dir,
|
||||
planning_model,
|
||||
max_thinking_tokens=planning_thinking_budget,
|
||||
)
|
||||
|
||||
# Generate follow-up planner prompt
|
||||
prompt = get_followup_planner_prompt(spec_dir)
|
||||
|
||||
print_status("Running follow-up planner...", "progress")
|
||||
print()
|
||||
|
||||
try:
|
||||
# Run single planning session
|
||||
async with client:
|
||||
status, response, error_info = await run_agent_session(
|
||||
client, prompt, spec_dir, verbose, phase=LogPhase.PLANNING
|
||||
)
|
||||
|
||||
# End planning phase in task logger
|
||||
if task_logger:
|
||||
task_logger.end_phase(
|
||||
LogPhase.PLANNING,
|
||||
success=(status != "error"),
|
||||
message="Follow-up planning session completed",
|
||||
)
|
||||
|
||||
if status == "error":
|
||||
print()
|
||||
print_status("Follow-up planning failed", "error")
|
||||
status_manager.update(state=BuildState.ERROR)
|
||||
return False
|
||||
|
||||
# Verify the plan was updated (should have pending subtasks now)
|
||||
plan_file = spec_dir / "implementation_plan.json"
|
||||
if plan_file.exists():
|
||||
plan = ImplementationPlan.load(plan_file)
|
||||
|
||||
# Check if there are any pending subtasks
|
||||
all_subtasks = [c for p in plan.phases for c in p.subtasks]
|
||||
pending_subtasks = [c for c in all_subtasks if c.status.value == "pending"]
|
||||
|
||||
if pending_subtasks:
|
||||
# Reset the plan status to in_progress (in case planner didn't)
|
||||
plan.reset_for_followup()
|
||||
await plan.async_save(plan_file)
|
||||
|
||||
print()
|
||||
content = [
|
||||
bold(f"{icon(Icons.SUCCESS)} FOLLOW-UP PLANNING COMPLETE"),
|
||||
"",
|
||||
f"New pending subtasks: {highlight(str(len(pending_subtasks)))}",
|
||||
f"Total subtasks: {len(all_subtasks)}",
|
||||
"",
|
||||
muted("Next steps:"),
|
||||
f" Run: {highlight(f'python auto-claude/run.py --spec {spec_dir.name}')}",
|
||||
]
|
||||
print(box(content, width=70, style="heavy"))
|
||||
print()
|
||||
status_manager.update(state=BuildState.PAUSED)
|
||||
return True
|
||||
else:
|
||||
print()
|
||||
print_status(
|
||||
"Warning: No pending subtasks found after planning", "warning"
|
||||
)
|
||||
print(muted("The planner may not have added new subtasks."))
|
||||
print(muted("Check implementation_plan.json manually."))
|
||||
status_manager.update(state=BuildState.PAUSED)
|
||||
return False
|
||||
else:
|
||||
print()
|
||||
print_status(
|
||||
"Error: implementation_plan.json not found after planning", "error"
|
||||
)
|
||||
status_manager.update(state=BuildState.ERROR)
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print()
|
||||
print_status(f"Follow-up planning error: {e}", "error")
|
||||
if task_logger:
|
||||
task_logger.log_error(f"Follow-up planning error: {e}", LogPhase.PLANNING)
|
||||
status_manager.update(state=BuildState.ERROR)
|
||||
return False
|
||||
"""
|
||||
Planner Agent Module
|
||||
====================
|
||||
|
||||
Handles follow-up planner sessions for adding new subtasks to completed specs.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
from core.client import create_client
|
||||
from phase_config import get_phase_model, get_phase_thinking_budget
|
||||
from phase_event import ExecutionPhase, emit_phase
|
||||
from task_logger import (
|
||||
LogPhase,
|
||||
get_task_logger,
|
||||
)
|
||||
from ui import (
|
||||
BuildState,
|
||||
Icons,
|
||||
StatusManager,
|
||||
bold,
|
||||
box,
|
||||
highlight,
|
||||
icon,
|
||||
muted,
|
||||
print_status,
|
||||
)
|
||||
|
||||
from .session import run_agent_session
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def run_followup_planner(
|
||||
project_dir: Path,
|
||||
spec_dir: Path,
|
||||
model: str,
|
||||
verbose: bool = False,
|
||||
) -> bool:
|
||||
"""
|
||||
Run the follow-up planner to add new subtasks to a completed spec.
|
||||
|
||||
This is a simplified version of run_autonomous_agent that:
|
||||
1. Creates a client
|
||||
2. Loads the followup planner prompt
|
||||
3. Runs a single planning session
|
||||
4. Returns after the plan is updated (doesn't enter coding loop)
|
||||
|
||||
The planner agent will:
|
||||
- Read FOLLOWUP_REQUEST.md for the new task
|
||||
- Read the existing implementation_plan.json
|
||||
- Add new phase(s) with pending subtasks
|
||||
- Update the plan status back to in_progress
|
||||
|
||||
Args:
|
||||
project_dir: Root directory for the project
|
||||
spec_dir: Directory containing the completed spec
|
||||
model: Claude model to use
|
||||
verbose: Whether to show detailed output
|
||||
|
||||
Returns:
|
||||
bool: True if planning completed successfully
|
||||
"""
|
||||
from implementation_plan import ImplementationPlan
|
||||
from prompts import get_followup_planner_prompt
|
||||
|
||||
# Initialize status manager for ccstatusline
|
||||
status_manager = StatusManager(project_dir)
|
||||
status_manager.set_active(spec_dir.name, BuildState.PLANNING)
|
||||
emit_phase(ExecutionPhase.PLANNING, "Follow-up planning")
|
||||
|
||||
# Initialize task logger for persistent logging
|
||||
task_logger = get_task_logger(spec_dir)
|
||||
|
||||
# Show header
|
||||
content = [
|
||||
bold(f"{icon(Icons.GEAR)} FOLLOW-UP PLANNER SESSION"),
|
||||
"",
|
||||
f"Spec: {highlight(spec_dir.name)}",
|
||||
muted("Adding follow-up work to completed spec."),
|
||||
"",
|
||||
muted("The agent will read your FOLLOWUP_REQUEST.md and add new subtasks."),
|
||||
]
|
||||
print()
|
||||
print(box(content, width=70, style="heavy"))
|
||||
print()
|
||||
|
||||
# Start planning phase in task logger
|
||||
if task_logger:
|
||||
task_logger.start_phase(LogPhase.PLANNING, "Starting follow-up planning...")
|
||||
task_logger.set_session(1)
|
||||
|
||||
# Create client with phase-specific model and thinking budget
|
||||
# Respects task_metadata.json configuration when no CLI override
|
||||
planning_model = get_phase_model(spec_dir, "planning", model)
|
||||
planning_thinking_budget = get_phase_thinking_budget(spec_dir, "planning")
|
||||
client = create_client(
|
||||
project_dir,
|
||||
spec_dir,
|
||||
planning_model,
|
||||
max_thinking_tokens=planning_thinking_budget,
|
||||
)
|
||||
|
||||
# Generate follow-up planner prompt
|
||||
prompt = get_followup_planner_prompt(spec_dir)
|
||||
|
||||
print_status("Running follow-up planner...", "progress")
|
||||
print()
|
||||
|
||||
try:
|
||||
# Run single planning session
|
||||
async with client:
|
||||
status, response, error_info = await run_agent_session(
|
||||
client, prompt, spec_dir, verbose, phase=LogPhase.PLANNING
|
||||
)
|
||||
|
||||
# End planning phase in task logger
|
||||
if task_logger:
|
||||
task_logger.end_phase(
|
||||
LogPhase.PLANNING,
|
||||
success=(status != "error"),
|
||||
message="Follow-up planning session completed",
|
||||
)
|
||||
|
||||
if status == "error":
|
||||
print()
|
||||
print_status("Follow-up planning failed", "error")
|
||||
status_manager.update(state=BuildState.ERROR)
|
||||
return False
|
||||
|
||||
# Verify the plan was updated (should have pending subtasks now)
|
||||
plan_file = spec_dir / "implementation_plan.json"
|
||||
if plan_file.exists():
|
||||
plan = ImplementationPlan.load(plan_file)
|
||||
|
||||
# Check if there are any pending subtasks
|
||||
all_subtasks = [c for p in plan.phases for c in p.subtasks]
|
||||
pending_subtasks = [c for c in all_subtasks if c.status.value == "pending"]
|
||||
|
||||
if pending_subtasks:
|
||||
# Reset the plan status to in_progress (in case planner didn't)
|
||||
plan.reset_for_followup()
|
||||
await plan.async_save(plan_file)
|
||||
|
||||
print()
|
||||
content = [
|
||||
bold(f"{icon(Icons.SUCCESS)} FOLLOW-UP PLANNING COMPLETE"),
|
||||
"",
|
||||
f"New pending subtasks: {highlight(str(len(pending_subtasks)))}",
|
||||
f"Total subtasks: {len(all_subtasks)}",
|
||||
"",
|
||||
muted("Next steps:"),
|
||||
f" Run: {highlight(f'python auto-claude/run.py --spec {spec_dir.name}')}",
|
||||
]
|
||||
print(box(content, width=70, style="heavy"))
|
||||
print()
|
||||
status_manager.update(state=BuildState.PAUSED)
|
||||
return True
|
||||
else:
|
||||
print()
|
||||
print_status(
|
||||
"Warning: No pending subtasks found after planning", "warning"
|
||||
)
|
||||
print(muted("The planner may not have added new subtasks."))
|
||||
print(muted("Check implementation_plan.json manually."))
|
||||
status_manager.update(state=BuildState.PAUSED)
|
||||
return False
|
||||
else:
|
||||
print()
|
||||
print_status(
|
||||
"Error: implementation_plan.json not found after planning", "error"
|
||||
)
|
||||
status_manager.update(state=BuildState.ERROR)
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print()
|
||||
print_status(f"Follow-up planning error: {e}", "error")
|
||||
if task_logger:
|
||||
task_logger.log_error(f"Follow-up planning error: {e}", LogPhase.PLANNING)
|
||||
status_manager.update(state=BuildState.ERROR)
|
||||
return False
|
||||
|
||||
+598
-598
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,101 @@
|
||||
"""
|
||||
Task event protocol for frontend XState synchronization.
|
||||
|
||||
Protocol: __TASK_EVENT__:{...}
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from uuid import uuid4
|
||||
|
||||
TASK_EVENT_PREFIX = "__TASK_EVENT__:"
|
||||
_DEBUG = os.environ.get("DEBUG", "").lower() in ("1", "true", "yes")
|
||||
|
||||
|
||||
@dataclass
|
||||
class TaskEventContext:
|
||||
task_id: str
|
||||
spec_id: str
|
||||
project_id: str
|
||||
sequence_start: int = 0
|
||||
|
||||
|
||||
def _load_task_metadata(spec_dir: Path) -> dict:
|
||||
metadata_path = spec_dir / "task_metadata.json"
|
||||
if not metadata_path.exists():
|
||||
return {}
|
||||
try:
|
||||
with open(metadata_path, encoding="utf-8") as f:
|
||||
return json.load(f)
|
||||
except (OSError, json.JSONDecodeError, UnicodeDecodeError):
|
||||
return {}
|
||||
|
||||
|
||||
def _load_last_sequence(spec_dir: Path) -> int:
|
||||
plan_path = spec_dir / "implementation_plan.json"
|
||||
if not plan_path.exists():
|
||||
return 0
|
||||
try:
|
||||
with open(plan_path, encoding="utf-8") as f:
|
||||
plan = json.load(f)
|
||||
last_event = plan.get("lastEvent") or {}
|
||||
seq = last_event.get("sequence")
|
||||
if isinstance(seq, int) and seq >= 0:
|
||||
return seq + 1
|
||||
except (OSError, json.JSONDecodeError, UnicodeDecodeError):
|
||||
return 0
|
||||
return 0
|
||||
|
||||
|
||||
def load_task_event_context(spec_dir: Path) -> TaskEventContext:
|
||||
metadata = _load_task_metadata(spec_dir)
|
||||
task_id = metadata.get("taskId") or metadata.get("task_id") or spec_dir.name
|
||||
spec_id = metadata.get("specId") or metadata.get("spec_id") or spec_dir.name
|
||||
project_id = metadata.get("projectId") or metadata.get("project_id") or ""
|
||||
sequence_start = _load_last_sequence(spec_dir)
|
||||
return TaskEventContext(
|
||||
task_id=str(task_id),
|
||||
spec_id=str(spec_id),
|
||||
project_id=str(project_id),
|
||||
sequence_start=sequence_start,
|
||||
)
|
||||
|
||||
|
||||
class TaskEventEmitter:
|
||||
def __init__(self, context: TaskEventContext) -> None:
|
||||
self._context = context
|
||||
self._sequence = context.sequence_start
|
||||
|
||||
@classmethod
|
||||
def from_spec_dir(cls, spec_dir: Path) -> TaskEventEmitter:
|
||||
return cls(load_task_event_context(spec_dir))
|
||||
|
||||
def emit(self, event_type: str, payload: dict | None = None) -> None:
|
||||
event = {
|
||||
"type": event_type,
|
||||
"taskId": self._context.task_id,
|
||||
"specId": self._context.spec_id,
|
||||
"projectId": self._context.project_id,
|
||||
"timestamp": datetime.now(timezone.utc).isoformat(),
|
||||
"eventId": str(uuid4()),
|
||||
"sequence": self._sequence,
|
||||
}
|
||||
if payload:
|
||||
event.update(payload)
|
||||
|
||||
try:
|
||||
print(f"{TASK_EVENT_PREFIX}{json.dumps(event, default=str)}", flush=True)
|
||||
self._sequence += 1
|
||||
except (OSError, UnicodeEncodeError) as e:
|
||||
if _DEBUG:
|
||||
try:
|
||||
sys.stderr.write(f"[task_event] emit failed: {e}\n")
|
||||
sys.stderr.flush()
|
||||
except (OSError, UnicodeEncodeError):
|
||||
pass # Silent on complete I/O failure
|
||||
+603
-531
File diff suppressed because it is too large
Load Diff
@@ -46,6 +46,7 @@ if sys.version_info < (3, 10): # noqa: UP036
|
||||
|
||||
import asyncio
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
@@ -252,9 +253,17 @@ Examples:
|
||||
# Find project root (look for auto-claude folder)
|
||||
project_dir = args.project_dir
|
||||
|
||||
# Auto-detect if running from within auto-claude directory (the source code)
|
||||
if project_dir.name == "auto-claude" and (project_dir / "run.py").exists():
|
||||
# Running from within auto-claude/ source directory, go up 1 level
|
||||
# Auto-detect if running from within auto-claude/apps/backend/ source directory.
|
||||
# This must be specific: check for run.py FILE (not dir) AND core/client.py to confirm
|
||||
# we're in the actual backend source tree, not just a project named "auto-claude".
|
||||
run_py_path = project_dir / "run.py"
|
||||
if (
|
||||
project_dir.name == "auto-claude"
|
||||
and run_py_path.exists()
|
||||
and run_py_path.is_file()
|
||||
and (project_dir / "core" / "client.py").exists()
|
||||
):
|
||||
# Running from within auto-claude/apps/backend/ source directory, go up 1 level
|
||||
project_dir = project_dir.parent
|
||||
elif not (project_dir / ".auto-claude").exists():
|
||||
# No .auto-claude folder found - try to find project root
|
||||
@@ -351,6 +360,36 @@ Examples:
|
||||
"--auto-continue", # Non-interactive mode for chained execution
|
||||
]
|
||||
|
||||
# Bypass approval re-validation when all conditions are met:
|
||||
# 1. Spec was auto-approved (no human review required)
|
||||
# 2. Spec creation succeeded (we're past the success check above)
|
||||
# 3. No review-before-coding gate was requested
|
||||
# This prevents hash mismatch failures when spec files are
|
||||
# touched between auto-approval and run.py startup.
|
||||
if args.auto_approve:
|
||||
# Default to requiring review (fail-closed) - only skip if explicitly disabled
|
||||
require_review = True
|
||||
task_meta_path = orchestrator.spec_dir / "task_metadata.json"
|
||||
if task_meta_path.exists():
|
||||
try:
|
||||
with open(task_meta_path, encoding="utf-8") as f:
|
||||
task_meta = json.load(f)
|
||||
require_review = task_meta.get(
|
||||
"requireReviewBeforeCoding", False
|
||||
)
|
||||
except (json.JSONDecodeError, OSError) as e:
|
||||
# On parse error, keep require_review=True (fail-closed)
|
||||
debug(
|
||||
"spec_runner",
|
||||
f"Failed to parse task_metadata.json, not adding --force: {e}",
|
||||
)
|
||||
if not require_review:
|
||||
run_cmd.append("--force")
|
||||
debug(
|
||||
"spec_runner",
|
||||
"Adding --force: auto-approved, no review required, spec completed",
|
||||
)
|
||||
|
||||
# Pass base branch if specified (for worktree creation)
|
||||
if args.base_branch:
|
||||
run_cmd.extend(["--base-branch", args.base_branch])
|
||||
|
||||
@@ -10,6 +10,7 @@ from collections.abc import Callable
|
||||
from pathlib import Path
|
||||
|
||||
from analysis.analyzers import analyze_project
|
||||
from core.task_event import TaskEventEmitter
|
||||
from core.workspace.models import SpecNumberLock
|
||||
from phase_config import get_thinking_budget
|
||||
from prompts_pkg.project_context import should_refresh_project_index
|
||||
@@ -234,6 +235,7 @@ class SpecOrchestrator:
|
||||
# Initialize task logger for planning phase
|
||||
task_logger = get_task_logger(self.spec_dir)
|
||||
task_logger.start_phase(LogPhase.PLANNING, "Starting spec creation process")
|
||||
TaskEventEmitter.from_spec_dir(self.spec_dir).emit("PLANNING_STARTED")
|
||||
|
||||
print(
|
||||
box(
|
||||
@@ -408,6 +410,28 @@ class SpecOrchestrator:
|
||||
LogPhase.PLANNING, success=True, message="Spec creation complete"
|
||||
)
|
||||
|
||||
# Load task metadata to check requireReviewBeforeCoding setting
|
||||
task_metadata_file = self.spec_dir / "task_metadata.json"
|
||||
require_review_before_coding = False
|
||||
if task_metadata_file.exists():
|
||||
with open(task_metadata_file, encoding="utf-8") as f:
|
||||
task_metadata = json.load(f)
|
||||
require_review_before_coding = task_metadata.get(
|
||||
"requireReviewBeforeCoding", False
|
||||
)
|
||||
|
||||
# Emit PLANNING_COMPLETE event for XState machine transition
|
||||
# This signals the frontend that spec creation is done
|
||||
task_emitter = TaskEventEmitter.from_spec_dir(self.spec_dir)
|
||||
task_emitter.emit(
|
||||
"PLANNING_COMPLETE",
|
||||
{
|
||||
"hasSubtasks": False, # Spec creation doesn't have subtasks yet
|
||||
"subtaskCount": 0,
|
||||
"requireReviewBeforeCoding": require_review_before_coding,
|
||||
},
|
||||
)
|
||||
|
||||
# === HUMAN REVIEW CHECKPOINT ===
|
||||
return self._run_review_checkpoint(auto_approve)
|
||||
|
||||
|
||||
@@ -0,0 +1,172 @@
|
||||
# XState Task State Machine Migration - Summary
|
||||
|
||||
**Issue:** #1338
|
||||
**PR:** #1575
|
||||
**Date:** 2026-01-28
|
||||
**Branch:** fix/1524-xstate-clean
|
||||
|
||||
## Overview
|
||||
|
||||
Migrated task status management from scattered decision logic across multiple handler files to a centralized XState v5 state machine. This eliminates race conditions, inconsistent status updates, and makes the task lifecycle formally defined and testable.
|
||||
|
||||
## Critical Dependencies & Blockers
|
||||
|
||||
### 1. Windows Credential Manager Fix (Required for Testing)
|
||||
**PR:** #1569 - fix(windows): fix Windows Credential Manager authentication
|
||||
**Issue:** #1525
|
||||
|
||||
This PR includes changes that depend on the Windows authentication fix. We could not complete end-to-end testing without this fix in place. If a different solution is implemented for #1525, we can remove these changes and resubmit.
|
||||
|
||||
### 2. spec_runner.py Project Detection Fix
|
||||
**Issue:** #1570 - spec_runner.py incorrectly detects auto-claude project as source directory
|
||||
|
||||
We encountered and fixed this bug during development as it was blocking our test workflow. The fix is included in this PR.
|
||||
|
||||
## Implementation Phases
|
||||
|
||||
| Phase | Description | Status |
|
||||
|-------|-------------|--------|
|
||||
| Phase 1 | Create XState machine definition (task-machine.ts) | ✅ Complete |
|
||||
| Phase 2 | Create TaskStateManager singleton wrapper | ✅ Complete |
|
||||
| Phase 3 | Integrate into agent-events-handlers.ts | ⏸️ Partially done |
|
||||
| Phase 4 | Remove legacy TaskStateMachine class | ❌ Not started |
|
||||
|
||||
### Why We Stopped at Phase 2
|
||||
|
||||
The original scope was to introduce XState as the new state management approach. Full integration (Phase 3-4) requires:
|
||||
|
||||
- Extensive refactoring of agent-events-handlers.ts to remove all legacy decision logic
|
||||
- Removing the old TaskStateMachine class entirely
|
||||
- Migration of all status persistence to go through XState
|
||||
|
||||
We delivered Phases 1-2 to establish the foundation. The current state has both systems running in parallel with XState as primary:
|
||||
|
||||
- **XState is primary:** When TaskStateManager returns a valid state transition, that decision is used
|
||||
- **Legacy as fallback:** The old TaskStateMachine logic only applies when XState doesn't produce a decision
|
||||
- **Safe rollback:** If XState causes issues, the legacy system is still present and can take over
|
||||
|
||||
This dual-system approach allows:
|
||||
- Validation that XState produces correct state transitions in production
|
||||
- Safe rollback if issues arise
|
||||
- Incremental adoption path for Phase 3-4
|
||||
|
||||
## What Changed
|
||||
|
||||
### Before (Old Architecture)
|
||||
- Status decisions scattered across agent-events-handlers.ts, execution-handlers.ts, worktree-handlers.ts
|
||||
- `validateStatusTransition()` function with complex conditional logic
|
||||
- TaskStateMachine class that was essentially an event emitter wrapper
|
||||
- Multiple places persisting status to implementation_plan.json
|
||||
- Race conditions possible when multiple handlers tried to update status
|
||||
|
||||
### After (New Architecture)
|
||||
- **Single source of truth:** TaskStateManager (XState-based singleton)
|
||||
- **Formal state machine:** taskMachine with explicit states and transitions
|
||||
- **Centralized persistence:** Status written to JSON from one place
|
||||
- **Testable:** Unit tests verify all state transitions
|
||||
- **Observable:** XState actors can be inspected/visualized
|
||||
|
||||
## State Machine States
|
||||
|
||||
```
|
||||
backlog → planning → coding → qa_review → qa_fixing → human_review → done
|
||||
↘ plan_review ↗ ↓
|
||||
error
|
||||
```
|
||||
|
||||
| State | Maps to Legacy Status | reviewReason |
|
||||
|-------|----------------------|--------------|
|
||||
| backlog | backlog | - |
|
||||
| planning | in_progress | - |
|
||||
| coding | in_progress | - |
|
||||
| plan_review | human_review | plan_review |
|
||||
| qa_review | ai_review | - |
|
||||
| qa_fixing | ai_review | - |
|
||||
| human_review | human_review | completed or stopped |
|
||||
| creating_pr | human_review | completed |
|
||||
| pr_created | pr_created | - |
|
||||
| error | human_review | errors |
|
||||
| done | done | - |
|
||||
|
||||
## Key Files
|
||||
|
||||
| File | Purpose |
|
||||
|------|---------|
|
||||
| `apps/frontend/src/shared/state-machines/task-machine.ts` | XState machine definition |
|
||||
| `apps/frontend/src/main/task-state-manager.ts` | Singleton service wrapping XState actors |
|
||||
| `apps/frontend/src/shared/state-machines/__tests__/task-machine.test.ts` | State machine unit tests (35 tests) |
|
||||
| `apps/frontend/src/main/__tests__/task-state-manager.test.ts` | Manager service unit tests (20 tests) |
|
||||
| `apps/frontend/src/main/ipc-handlers/agent-events-handlers.ts` | Refactored to call TaskStateManager |
|
||||
|
||||
## Events
|
||||
|
||||
The state machine responds to these events:
|
||||
|
||||
| Event | Triggered By |
|
||||
|-------|-------------|
|
||||
| PLANNING_STARTED | Execution progress phase=planning |
|
||||
| PLANNING_COMPLETE | Execution progress moving past planning |
|
||||
| PLAN_APPROVED | User clicks "Proceed to Coding" from plan_review |
|
||||
| CODING_STARTED | Execution progress phase=coding |
|
||||
| QA_STARTED | Execution progress phase=qa_review |
|
||||
| QA_PASSED | Execution progress phase=complete |
|
||||
| QA_FAILED | Execution progress phase=qa_fixing |
|
||||
| PROCESS_EXITED | Agent process exit event |
|
||||
| USER_STOPPED | User clicks stop |
|
||||
| USER_RESUMED | User resumes task |
|
||||
| MARK_DONE | User marks task as done |
|
||||
| CREATE_PR | User initiates PR creation |
|
||||
| PR_CREATED | PR successfully created |
|
||||
|
||||
## Rollback Plan
|
||||
|
||||
If issues arise post-merge:
|
||||
|
||||
1. **Quick rollback:** `git revert <merge-commit>`
|
||||
2. **Restore point:** Commit 3e5f004a has old code intact
|
||||
3. **Legacy persistence still works:** implementation_plan.json continues to store status
|
||||
|
||||
## Testing
|
||||
|
||||
| Test Suite | Result |
|
||||
|------------|--------|
|
||||
| Frontend unit tests | ✅ 2579 passed |
|
||||
| TypeScript strict mode | ✅ Pass |
|
||||
| Biome lint | ✅ Pass |
|
||||
| XState machine tests | ✅ 35 passed |
|
||||
| TaskStateManager tests | ✅ 20 passed |
|
||||
| Python backend tests | ✅ Pass |
|
||||
|
||||
## Session Fixes (2026-01-28)
|
||||
|
||||
### Fixed Issues
|
||||
|
||||
1. **Badge showing "Needs Review" instead of "Complete"** - Added `effectiveReviewReason` logic in TaskCard.tsx that sets 'completed' when phase === 'complete'
|
||||
|
||||
2. **Task showing "Incomplete" badge for plan_review** - Added 'plan_review' to exclusion list in `isIncompleteHumanReview`
|
||||
|
||||
3. **Missing "Proceed to Coding" button** - Restored in WorkspaceMessages.tsx for plan_review flow
|
||||
|
||||
4. **Wrong XState event for plan_review → coding** - Fixed to send PLAN_APPROVED instead of PLANNING_STARTED when starting from plan_review state
|
||||
|
||||
5. **Stuck detection logic** - Reverted useTaskDetail.ts to simpler logic from working branch (only skip 'planning' phase, 2s timeout)
|
||||
|
||||
## Outstanding Items (Requires PM Input)
|
||||
|
||||
### 1. Future: Subtask XState Migration
|
||||
- **Issue:** `subtask.status` is checked directly in UI code
|
||||
- **Recommendation:** Should be managed by state machine for consistency
|
||||
- **Status:** Out of scope for current PR, document for future work
|
||||
|
||||
## Future Improvements
|
||||
|
||||
- Add @stately-ai/inspect for runtime devtools
|
||||
- **Subtask state management** - Track individual subtask states within the machine using XState parallel states
|
||||
- Add more granular QA states (qa_round_1, qa_round_2, etc.)
|
||||
- Complete Phase 3-4: Full integration and removal of legacy TaskStateMachine class
|
||||
|
||||
## Visualization
|
||||
|
||||
The state machine can be visualized at [Stately.ai Editor](https://stately.ai/editor):
|
||||
1. Paste the contents of task-machine.ts
|
||||
2. Click "Visualize" to see the state diagram
|
||||
@@ -100,6 +100,7 @@
|
||||
"semver": "^7.7.3",
|
||||
"tailwind-merge": "^3.4.0",
|
||||
"uuid": "^13.0.0",
|
||||
"xstate": "^5.26.0",
|
||||
"zod": "^4.2.1",
|
||||
"zustand": "^5.0.9"
|
||||
},
|
||||
|
||||
@@ -396,7 +396,7 @@ describe('E2E Smoke Tests', () => {
|
||||
statusHandler({}, 'task-001', 'in_progress');
|
||||
}
|
||||
|
||||
expect(statusCallback).toHaveBeenCalledWith('task-001', 'in_progress', undefined);
|
||||
expect(statusCallback).toHaveBeenCalledWith('task-001', 'in_progress', undefined, undefined);
|
||||
|
||||
// Cleanup listeners
|
||||
cleanupProgress();
|
||||
@@ -656,6 +656,7 @@ describe('E2E Smoke Tests', () => {
|
||||
index + 1,
|
||||
'task-001',
|
||||
status,
|
||||
undefined,
|
||||
undefined
|
||||
);
|
||||
});
|
||||
|
||||
@@ -395,17 +395,16 @@ describe('Subprocess Spawn Integration', () => {
|
||||
expect(manager.getRunningTasks()).toHaveLength(2);
|
||||
}, { timeout: 5000 });
|
||||
|
||||
// Wait for spawn to complete (ensures exit handlers are attached)
|
||||
await new Promise(resolve => setImmediate(resolve));
|
||||
|
||||
// Emit exit events - both tasks share the same mockProcess, so both handlers fire
|
||||
// We emit twice to ensure both task handlers receive exit events
|
||||
mockProcess.emit('exit', 0);
|
||||
mockProcess.emit('exit', 0);
|
||||
|
||||
// Wait for promises to settle
|
||||
// Wait for both spawn promises to fully resolve — this ensures the exit
|
||||
// handlers are attached to mockProcess. A single setImmediate is NOT enough
|
||||
// on Windows CI because spawnProcess has async operations (getAPIProfileEnv,
|
||||
// getRecoveryCoordinator) between addProcess and the .on('exit') listener.
|
||||
// Waiting for the promises guarantees spawnProcess has completed fully.
|
||||
await Promise.allSettled([promise1, promise2]);
|
||||
|
||||
// Both tasks share the same mockProcess, so one emit fires both exit handlers
|
||||
mockProcess.emit('exit', 0);
|
||||
|
||||
// Wait for tasks to be removed from tracking (cleanup may be async)
|
||||
await vi.waitFor(() => {
|
||||
expect(manager.getRunningTasks()).toHaveLength(0);
|
||||
|
||||
@@ -241,12 +241,12 @@ describe('Task Lifecycle Integration', () => {
|
||||
)?.[1];
|
||||
|
||||
if (eventHandler) {
|
||||
eventHandler({}, 'task-001', 'spec_complete');
|
||||
eventHandler({}, 'task-001', 'spec_complete', undefined, undefined);
|
||||
}
|
||||
|
||||
// Verify callback was invoked with correct parameters (taskId, status, projectId)
|
||||
// Note: projectId is optional and undefined when not provided
|
||||
expect(callback).toHaveBeenCalledWith('task-001', 'spec_complete', undefined);
|
||||
// Verify callback was invoked with correct parameters (taskId, status, projectId, reviewReason)
|
||||
// Note: projectId/reviewReason are optional and undefined when not provided
|
||||
expect(callback).toHaveBeenCalledWith('task-001', 'spec_complete', undefined, undefined);
|
||||
});
|
||||
|
||||
it('should emit task:progress event with updated plan during spec creation', async () => {
|
||||
@@ -379,4 +379,4 @@ describe('Task Lifecycle Integration', () => {
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
@@ -689,7 +689,8 @@ describe("IPC Handlers", { timeout: 30000 }, () => {
|
||||
"task:statusChange",
|
||||
"task-1",
|
||||
"human_review",
|
||||
expect.any(String) // projectId for multi-project filtering
|
||||
expect.any(String), // projectId for multi-project filtering
|
||||
"errors"
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -292,6 +292,7 @@ describe('ProjectStore', () => {
|
||||
feature: 'Test Feature',
|
||||
workflow_type: 'feature',
|
||||
services_involved: [],
|
||||
status: 'in_progress',
|
||||
phases: [
|
||||
{
|
||||
phase: 1,
|
||||
@@ -338,6 +339,7 @@ describe('ProjectStore', () => {
|
||||
feature: 'Pending Feature',
|
||||
workflow_type: 'feature',
|
||||
services_involved: [],
|
||||
status: 'backlog',
|
||||
phases: [
|
||||
{
|
||||
phase: 1,
|
||||
@@ -377,6 +379,7 @@ describe('ProjectStore', () => {
|
||||
feature: 'Complete Feature',
|
||||
workflow_type: 'feature',
|
||||
services_involved: [],
|
||||
status: 'ai_review',
|
||||
phases: [
|
||||
{
|
||||
phase: 1,
|
||||
@@ -408,7 +411,7 @@ describe('ProjectStore', () => {
|
||||
expect(tasks[0].status).toBe('ai_review');
|
||||
});
|
||||
|
||||
it('should determine status as human_review when QA report rejected', async () => {
|
||||
it('should determine status as human_review when plan status is human_review', async () => {
|
||||
const specsDir = path.join(TEST_PROJECT_PATH, '.auto-claude', 'specs', '004-rejected');
|
||||
mkdirSync(specsDir, { recursive: true });
|
||||
|
||||
@@ -416,6 +419,8 @@ describe('ProjectStore', () => {
|
||||
feature: 'Rejected Feature',
|
||||
workflow_type: 'feature',
|
||||
services_involved: [],
|
||||
status: 'human_review',
|
||||
reviewReason: 'qa_rejected',
|
||||
phases: [
|
||||
{
|
||||
phase: 1,
|
||||
@@ -437,11 +442,6 @@ describe('ProjectStore', () => {
|
||||
JSON.stringify(plan)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
path.join(specsDir, 'qa_report.md'),
|
||||
'# QA Report\n\nStatus: REJECTED\n'
|
||||
);
|
||||
|
||||
const { ProjectStore } = await import('../project-store');
|
||||
const store = new ProjectStore();
|
||||
|
||||
@@ -451,8 +451,7 @@ describe('ProjectStore', () => {
|
||||
expect(tasks[0].status).toBe('human_review');
|
||||
});
|
||||
|
||||
it('should determine status as human_review when QA report approved', async () => {
|
||||
// QA approval moves task to human_review (user needs to review before marking done)
|
||||
it('should determine reviewReason from plan when status is human_review', async () => {
|
||||
const specsDir = path.join(TEST_PROJECT_PATH, '.auto-claude', 'specs', '005-approved');
|
||||
mkdirSync(specsDir, { recursive: true });
|
||||
|
||||
@@ -460,6 +459,8 @@ describe('ProjectStore', () => {
|
||||
feature: 'Approved Feature',
|
||||
workflow_type: 'feature',
|
||||
services_involved: [],
|
||||
status: 'human_review',
|
||||
reviewReason: 'completed',
|
||||
phases: [
|
||||
{
|
||||
phase: 1,
|
||||
@@ -481,11 +482,6 @@ describe('ProjectStore', () => {
|
||||
JSON.stringify(plan)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
path.join(specsDir, 'qa_report.md'),
|
||||
'# QA Report\n\nStatus: APPROVED\n'
|
||||
);
|
||||
|
||||
const { ProjectStore } = await import('../project-store');
|
||||
const store = new ProjectStore();
|
||||
|
||||
|
||||
@@ -0,0 +1,444 @@
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
||||
import { TaskStateManager } from '../task-state-manager';
|
||||
import type { Task, Project } from '../../shared/types';
|
||||
|
||||
// Mock dependencies
|
||||
vi.mock('../ipc-handlers/utils', () => ({
|
||||
safeSendToRenderer: vi.fn()
|
||||
}));
|
||||
|
||||
vi.mock('../ipc-handlers/task/plan-file-utils', () => ({
|
||||
getPlanPath: vi.fn(() => '/mock/path/implementation_plan.json'),
|
||||
persistPlanStatusAndReasonSync: vi.fn()
|
||||
}));
|
||||
|
||||
vi.mock('../worktree-paths', () => ({
|
||||
findTaskWorktree: vi.fn(() => null)
|
||||
}));
|
||||
|
||||
vi.mock('fs', () => ({
|
||||
existsSync: vi.fn(() => false)
|
||||
}));
|
||||
|
||||
// Create mock task and project
|
||||
function createMockTask(overrides: Partial<Task> = {}): Task {
|
||||
return {
|
||||
id: 'test-task-id',
|
||||
specId: '001-test-spec',
|
||||
projectId: 'test-project-id',
|
||||
title: 'Test Task',
|
||||
description: 'Test description',
|
||||
status: 'backlog',
|
||||
subtasks: [],
|
||||
logs: [],
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
...overrides
|
||||
};
|
||||
}
|
||||
|
||||
function createMockProject(overrides: Partial<Project> = {}): Project {
|
||||
return {
|
||||
id: 'test-project-id',
|
||||
name: 'Test Project',
|
||||
path: '/mock/project/path',
|
||||
createdAt: new Date().toISOString(),
|
||||
lastOpenedAt: new Date().toISOString(),
|
||||
...overrides
|
||||
} as Project;
|
||||
}
|
||||
|
||||
describe('TaskStateManager', () => {
|
||||
let manager: TaskStateManager;
|
||||
let mockTask: Task;
|
||||
let mockProject: Project;
|
||||
|
||||
beforeEach(() => {
|
||||
manager = new TaskStateManager();
|
||||
mockTask = createMockTask();
|
||||
mockProject = createMockProject();
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
manager.clearAllTasks();
|
||||
});
|
||||
|
||||
describe('handleTaskEvent', () => {
|
||||
it('should accept events with increasing sequence numbers', () => {
|
||||
const event1 = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0
|
||||
};
|
||||
|
||||
const event2 = {
|
||||
type: 'PLANNING_COMPLETE',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-2',
|
||||
sequence: 1,
|
||||
hasSubtasks: true,
|
||||
subtaskCount: 1,
|
||||
requireReviewBeforeCoding: false
|
||||
};
|
||||
|
||||
const result1 = manager.handleTaskEvent(mockTask.id, event1, mockTask, mockProject);
|
||||
const result2 = manager.handleTaskEvent(mockTask.id, event2, mockTask, mockProject);
|
||||
|
||||
expect(result1).toBe(true);
|
||||
expect(result2).toBe(true);
|
||||
});
|
||||
|
||||
it('should reject events with stale sequence numbers', () => {
|
||||
const event1 = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 5
|
||||
};
|
||||
|
||||
const event2 = {
|
||||
type: 'PLANNING_COMPLETE',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-2',
|
||||
sequence: 3, // Older than event1
|
||||
hasSubtasks: true,
|
||||
subtaskCount: 1,
|
||||
requireReviewBeforeCoding: false
|
||||
};
|
||||
|
||||
const result1 = manager.handleTaskEvent(mockTask.id, event1, mockTask, mockProject);
|
||||
const result2 = manager.handleTaskEvent(mockTask.id, event2, mockTask, mockProject);
|
||||
|
||||
expect(result1).toBe(true);
|
||||
expect(result2).toBe(false); // Should be rejected
|
||||
});
|
||||
|
||||
it('should accept events with equal sequence numbers (edge case)', () => {
|
||||
// This handles reload scenarios where we might see the same sequence
|
||||
const event1 = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 5
|
||||
};
|
||||
|
||||
const event2 = {
|
||||
type: 'PLANNING_COMPLETE',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-2',
|
||||
sequence: 5, // Same as event1
|
||||
hasSubtasks: true,
|
||||
subtaskCount: 1,
|
||||
requireReviewBeforeCoding: false
|
||||
};
|
||||
|
||||
const result1 = manager.handleTaskEvent(mockTask.id, event1, mockTask, mockProject);
|
||||
const result2 = manager.handleTaskEvent(mockTask.id, event2, mockTask, mockProject);
|
||||
|
||||
expect(result1).toBe(true);
|
||||
expect(result2).toBe(true); // Should be accepted (>= comparison)
|
||||
});
|
||||
});
|
||||
|
||||
describe('handleUiEvent', () => {
|
||||
it('should send PLAN_APPROVED event correctly', () => {
|
||||
// First, set up the task in plan_review state
|
||||
const planningEvent = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0
|
||||
};
|
||||
|
||||
const planCompleteEvent = {
|
||||
type: 'PLANNING_COMPLETE',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-2',
|
||||
sequence: 1,
|
||||
hasSubtasks: true,
|
||||
subtaskCount: 1,
|
||||
requireReviewBeforeCoding: true // This will cause plan_review state
|
||||
};
|
||||
|
||||
manager.handleTaskEvent(mockTask.id, planningEvent, mockTask, mockProject);
|
||||
manager.handleTaskEvent(mockTask.id, planCompleteEvent, mockTask, mockProject);
|
||||
|
||||
// Now send PLAN_APPROVED
|
||||
manager.handleUiEvent(mockTask.id, { type: 'PLAN_APPROVED' }, mockTask, mockProject);
|
||||
|
||||
// The actor should now be in 'coding' state
|
||||
// We can't easily check the state directly, but we can verify no errors occurred
|
||||
});
|
||||
|
||||
it('should send USER_STOPPED event correctly', () => {
|
||||
const event = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0
|
||||
};
|
||||
|
||||
manager.handleTaskEvent(mockTask.id, event, mockTask, mockProject);
|
||||
manager.handleUiEvent(mockTask.id, { type: 'USER_STOPPED', hasPlan: false }, mockTask, mockProject);
|
||||
|
||||
// Should not throw
|
||||
});
|
||||
});
|
||||
|
||||
describe('handleManualStatusChange', () => {
|
||||
it('should handle done status', () => {
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'done', mockTask, mockProject);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle pr_created status', () => {
|
||||
const taskWithPrUrl = createMockTask({ metadata: { prUrl: 'https://github.com/test/pr/1' } });
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'pr_created', taskWithPrUrl, mockProject);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle in_progress status with plan_review', () => {
|
||||
const taskInPlanReview = createMockTask({
|
||||
status: 'human_review',
|
||||
reviewReason: 'plan_review'
|
||||
});
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'in_progress', taskInPlanReview, mockProject);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle in_progress status without plan_review', () => {
|
||||
const stoppedTask = createMockTask({
|
||||
status: 'human_review',
|
||||
reviewReason: 'stopped'
|
||||
});
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'in_progress', stoppedTask, mockProject);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle backlog status', () => {
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'backlog', mockTask, mockProject);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle human_review status (stage-only merge keeps task in review)', () => {
|
||||
const taskInReview = createMockTask({
|
||||
status: 'human_review',
|
||||
reviewReason: 'completed'
|
||||
});
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'human_review', taskInReview, mockProject);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle human_review with default reviewReason when task has none', () => {
|
||||
const taskNoReason = createMockTask({
|
||||
status: 'human_review'
|
||||
// no reviewReason set
|
||||
});
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'human_review', taskNoReason, mockProject);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should return false for unhandled status', () => {
|
||||
const result = manager.handleManualStatusChange(mockTask.id, 'ai_review', mockTask, mockProject);
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('sequence management', () => {
|
||||
it('should set and get last sequence', () => {
|
||||
manager.setLastSequence(mockTask.id, 42);
|
||||
expect(manager.getLastSequence(mockTask.id)).toBe(42);
|
||||
});
|
||||
|
||||
it('should return undefined for unknown task', () => {
|
||||
expect(manager.getLastSequence('unknown-task')).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('clearTask', () => {
|
||||
it('should clear task state', () => {
|
||||
// Set up some state
|
||||
manager.setLastSequence(mockTask.id, 10);
|
||||
|
||||
const event = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0
|
||||
};
|
||||
manager.handleTaskEvent(mockTask.id, event, mockTask, mockProject);
|
||||
|
||||
// Clear
|
||||
manager.clearTask(mockTask.id);
|
||||
|
||||
// Verify cleared
|
||||
expect(manager.getLastSequence(mockTask.id)).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('clearAllTasks', () => {
|
||||
it('should clear all task state', () => {
|
||||
// Set up state for multiple tasks
|
||||
manager.setLastSequence('task-1', 10);
|
||||
manager.setLastSequence('task-2', 20);
|
||||
|
||||
const event1 = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: 'task-1',
|
||||
specId: '001',
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0
|
||||
};
|
||||
const event2 = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: 'task-2',
|
||||
specId: '002',
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-2',
|
||||
sequence: 0
|
||||
};
|
||||
|
||||
manager.handleTaskEvent('task-1', event1, createMockTask({ id: 'task-1' }), mockProject);
|
||||
manager.handleTaskEvent('task-2', event2, createMockTask({ id: 'task-2' }), mockProject);
|
||||
|
||||
// Clear all
|
||||
manager.clearAllTasks();
|
||||
|
||||
// Verify actors and state are cleared, but sequence tracking is preserved
|
||||
// (to prevent duplicate event processing during refresh window)
|
||||
expect(manager.getLastSequence('task-1')).toBe(10);
|
||||
expect(manager.getLastSequence('task-2')).toBe(20);
|
||||
});
|
||||
});
|
||||
|
||||
describe('handleProcessExited', () => {
|
||||
it('should NOT mark as error if terminal event was already seen', () => {
|
||||
// First send a terminal event (like QA_PASSED)
|
||||
const qaPassedEvent = {
|
||||
type: 'QA_PASSED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0,
|
||||
iteration: 1,
|
||||
testsRun: {}
|
||||
};
|
||||
|
||||
manager.handleTaskEvent(mockTask.id, qaPassedEvent, mockTask, mockProject);
|
||||
|
||||
// Now process exits - this should NOT trigger error state
|
||||
manager.handleProcessExited(mockTask.id, 0, mockTask, mockProject);
|
||||
|
||||
// Should not throw and should not transition to error
|
||||
// (We can't easily verify the state, but the important thing is no crash)
|
||||
});
|
||||
|
||||
it('should mark as error on unexpected exit when no terminal event seen', () => {
|
||||
// Start a task
|
||||
const planningEvent = {
|
||||
type: 'PLANNING_STARTED',
|
||||
taskId: mockTask.id,
|
||||
specId: mockTask.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0
|
||||
};
|
||||
|
||||
manager.handleTaskEvent(mockTask.id, planningEvent, mockTask, mockProject);
|
||||
|
||||
// Process exits unexpectedly (no terminal event seen)
|
||||
manager.handleProcessExited(mockTask.id, 1, mockTask, mockProject);
|
||||
|
||||
// Should have sent PROCESS_EXITED event with unexpected=true
|
||||
// This should transition to error state
|
||||
});
|
||||
});
|
||||
|
||||
describe('actor state restoration', () => {
|
||||
it('should restore actor state from task with in_progress status', () => {
|
||||
const taskInProgress = createMockTask({
|
||||
status: 'in_progress',
|
||||
executionProgress: { phase: 'coding', phaseProgress: 50, overallProgress: 50 }
|
||||
});
|
||||
|
||||
const event = {
|
||||
type: 'QA_STARTED',
|
||||
taskId: taskInProgress.id,
|
||||
specId: taskInProgress.specId,
|
||||
projectId: mockProject.id,
|
||||
timestamp: new Date().toISOString(),
|
||||
eventId: 'evt-1',
|
||||
sequence: 0,
|
||||
iteration: 1,
|
||||
maxIterations: 3
|
||||
};
|
||||
|
||||
// This should create an actor restored to 'coding' state, then transition to 'qa_review'
|
||||
manager.handleTaskEvent(taskInProgress.id, event, taskInProgress, mockProject);
|
||||
|
||||
// No error should occur
|
||||
});
|
||||
|
||||
it('should restore actor state from task with human_review/plan_review', () => {
|
||||
const taskInPlanReview = createMockTask({
|
||||
status: 'human_review',
|
||||
reviewReason: 'plan_review'
|
||||
});
|
||||
|
||||
// Actor should be created in plan_review state
|
||||
manager.handleUiEvent(taskInPlanReview.id, { type: 'PLAN_APPROVED' }, taskInPlanReview, mockProject);
|
||||
|
||||
// Should transition from plan_review to coding without error
|
||||
});
|
||||
|
||||
it('should restore actor state from task with error status', () => {
|
||||
const taskInError = createMockTask({
|
||||
status: 'error',
|
||||
reviewReason: 'errors'
|
||||
});
|
||||
|
||||
// Actor should be created in error state
|
||||
manager.handleUiEvent(taskInError.id, { type: 'USER_RESUMED' }, taskInError, mockProject);
|
||||
|
||||
// Should transition from error to coding without error
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -43,6 +43,7 @@ export class AgentEvents {
|
||||
const lowerLog = log.toLowerCase();
|
||||
|
||||
// Spec runner phase detection (all part of "planning")
|
||||
// IMPORTANT: Spec runner should NEVER transition to coding/qa phases via fallback matching
|
||||
if (isSpecRunner) {
|
||||
if (lowerLog.includes('discovering') || lowerLog.includes('discovery')) {
|
||||
return { phase: 'planning', message: 'Discovering project context...' };
|
||||
@@ -59,6 +60,8 @@ export class AgentEvents {
|
||||
if (lowerLog.includes('spec complete') || lowerLog.includes('specification complete')) {
|
||||
return { phase: 'planning', message: 'Specification complete' };
|
||||
}
|
||||
// Spec runner: don't fall through to run.py patterns (would incorrectly detect coding phase)
|
||||
return null;
|
||||
}
|
||||
|
||||
// Run.py phase detection
|
||||
|
||||
@@ -12,6 +12,7 @@ import { AgentState } from './agent-state';
|
||||
import { AgentEvents } from './agent-events';
|
||||
import { ProcessType, ExecutionProgressData } from './types';
|
||||
import type { CompletablePhase } from '../../shared/constants/phase-protocol';
|
||||
import { parseTaskEvent } from './task-event-parser';
|
||||
import { detectRateLimit, createSDKRateLimitInfo, getBestAvailableProfileEnv, detectAuthFailure } from '../rate-limit-detector';
|
||||
import { getAPIProfileEnv } from '../services/profile';
|
||||
import { projectStore } from '../project-store';
|
||||
@@ -620,6 +621,17 @@ export class AgentProcessManager {
|
||||
console.log(`[PhaseDebug:${taskId}] Found marker in line: "${line.substring(0, 200)}"`);
|
||||
}
|
||||
|
||||
// Log all task event markers for debugging
|
||||
if (line.includes('__TASK_EVENT__')) {
|
||||
console.log(`[AgentProcess:${taskId}] Found __TASK_EVENT__ marker in line:`, line.substring(0, 300));
|
||||
}
|
||||
|
||||
const taskEvent = parseTaskEvent(line);
|
||||
if (taskEvent) {
|
||||
console.log(`[AgentProcess:${taskId}] Parsed task event:`, taskEvent.type, taskEvent);
|
||||
this.emitter.emit('task-event', taskId, taskEvent);
|
||||
}
|
||||
|
||||
const phaseUpdate = this.events.parseExecutionPhase(line, currentPhase, isSpecRunner);
|
||||
|
||||
if (isDebug && hasMarker) {
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
/**
|
||||
* Structured task event parser for Python -> TypeScript protocol.
|
||||
* Protocol: __TASK_EVENT__:{...}
|
||||
*/
|
||||
|
||||
import { validateTaskEvent, type TaskEventPayload } from './task-event-schema';
|
||||
|
||||
export const TASK_EVENT_PREFIX = '__TASK_EVENT__:';
|
||||
|
||||
const DEBUG = process.env.DEBUG?.toLowerCase() === 'true' || process.env.DEBUG === '1';
|
||||
|
||||
export type TaskEvent = TaskEventPayload;
|
||||
|
||||
export function parseTaskEvent(line: string): TaskEventPayload | null {
|
||||
const markerIndex = line.indexOf(TASK_EVENT_PREFIX);
|
||||
if (markerIndex === -1) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (DEBUG) {
|
||||
console.log('[task-event-parser] Found marker at index', markerIndex, 'in line:', line.substring(0, 200));
|
||||
}
|
||||
|
||||
const rawJsonStr = line.slice(markerIndex + TASK_EVENT_PREFIX.length).trim();
|
||||
if (!rawJsonStr) {
|
||||
if (DEBUG) {
|
||||
console.log('[task-event-parser] Empty JSON string after marker');
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
const jsonStr = extractJsonObject(rawJsonStr);
|
||||
if (!jsonStr) {
|
||||
if (DEBUG) {
|
||||
console.log('[task-event-parser] Could not extract JSON object from:', rawJsonStr.substring(0, 200));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
if (DEBUG) {
|
||||
console.log('[task-event-parser] Attempting to parse JSON:', jsonStr.substring(0, 200));
|
||||
}
|
||||
|
||||
try {
|
||||
const rawPayload = JSON.parse(jsonStr) as unknown;
|
||||
const result = validateTaskEvent(rawPayload);
|
||||
|
||||
if (!result.success) {
|
||||
if (DEBUG) {
|
||||
console.log('[task-event-parser] Validation failed:', result.error.format());
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
if (DEBUG) {
|
||||
console.log('[task-event-parser] Successfully parsed event:', result.data);
|
||||
}
|
||||
|
||||
return result.data;
|
||||
} catch (e) {
|
||||
if (DEBUG) {
|
||||
console.log('[task-event-parser] JSON parse FAILED for:', jsonStr);
|
||||
console.log('[task-event-parser] Error:', e);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export function hasTaskMarker(line: string): boolean {
|
||||
return line.includes(TASK_EVENT_PREFIX);
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract a JSON object from a string that may have trailing garbage.
|
||||
* Finds the matching closing brace for the first opening brace.
|
||||
*/
|
||||
function extractJsonObject(str: string): string | null {
|
||||
const firstBrace = str.indexOf('{');
|
||||
if (firstBrace === -1) {
|
||||
return null;
|
||||
}
|
||||
|
||||
let depth = 0;
|
||||
let inString = false;
|
||||
let isEscaped = false;
|
||||
|
||||
for (let i = firstBrace; i < str.length; i++) {
|
||||
const char = str[i];
|
||||
|
||||
if (isEscaped) {
|
||||
isEscaped = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (char === '\\' && inString) {
|
||||
isEscaped = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (char === '"') {
|
||||
inString = !inString;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (inString) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (char === '{') {
|
||||
depth++;
|
||||
} else if (char === '}') {
|
||||
depth--;
|
||||
if (depth === 0) {
|
||||
return str.slice(firstBrace, i + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
import { z } from 'zod';
|
||||
|
||||
export const TaskEventSchema = z.object({
|
||||
type: z.string(),
|
||||
taskId: z.string(),
|
||||
specId: z.string(),
|
||||
projectId: z.string(),
|
||||
timestamp: z.string(),
|
||||
eventId: z.string(),
|
||||
sequence: z.number().int().min(0)
|
||||
}).passthrough();
|
||||
|
||||
export type TaskEventPayload = z.infer<typeof TaskEventSchema>;
|
||||
|
||||
export interface ValidationResult {
|
||||
success: true;
|
||||
data: TaskEventPayload;
|
||||
}
|
||||
|
||||
export interface ValidationError {
|
||||
success: false;
|
||||
error: z.ZodError;
|
||||
}
|
||||
|
||||
export type ParseResult = ValidationResult | ValidationError;
|
||||
|
||||
export function validateTaskEvent(data: unknown): ParseResult {
|
||||
const result = TaskEventSchema.safeParse(data);
|
||||
if (result.success) {
|
||||
return { success: true, data: result.data as TaskEventPayload };
|
||||
}
|
||||
return { success: false, error: result.error };
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
import { ChildProcess } from 'child_process';
|
||||
import type { IdeationConfig } from '../../shared/types';
|
||||
import type { CompletablePhase } from '../../shared/constants/phase-protocol';
|
||||
import type { TaskEventPayload } from './task-event-schema';
|
||||
|
||||
/**
|
||||
* Agent-specific types for process and state management
|
||||
@@ -34,6 +35,7 @@ export interface AgentManagerEvents {
|
||||
error: (taskId: string, error: string) => void;
|
||||
exit: (taskId: string, code: number | null, processType: ProcessType) => void;
|
||||
'execution-progress': (taskId: string, progress: ExecutionProgressData) => void;
|
||||
'task-event': (taskId: string, event: TaskEventPayload) => void;
|
||||
}
|
||||
|
||||
// IdeationConfig now imported from shared types to maintain consistency
|
||||
|
||||
@@ -1,106 +1,23 @@
|
||||
import type { BrowserWindow } from "electron";
|
||||
import path from "path";
|
||||
import { existsSync } from "fs";
|
||||
import { existsSync, readFileSync } from "fs";
|
||||
import { IPC_CHANNELS, AUTO_BUILD_PATHS, getSpecsDir } from "../../shared/constants";
|
||||
import {
|
||||
wouldPhaseRegress,
|
||||
isTerminalPhase,
|
||||
isValidExecutionPhase,
|
||||
isValidPhaseTransition,
|
||||
type ExecutionPhase,
|
||||
} from "../../shared/constants/phase-protocol";
|
||||
import type {
|
||||
SDKRateLimitInfo,
|
||||
AuthFailureInfo,
|
||||
Task,
|
||||
TaskStatus,
|
||||
Project,
|
||||
ImplementationPlan,
|
||||
} from "../../shared/types";
|
||||
import { AgentManager } from "../agent";
|
||||
import type { ProcessType, ExecutionProgressData } from "../agent";
|
||||
import { titleGenerator } from "../title-generator";
|
||||
import { fileWatcher } from "../file-watcher";
|
||||
import { projectStore } from "../project-store";
|
||||
import { notificationService } from "../notification-service";
|
||||
import { persistPlanStatusSync, getPlanPath } from "./task/plan-file-utils";
|
||||
import { persistPlanLastEventSync, getPlanPath, persistPlanPhaseSync } from "./task/plan-file-utils";
|
||||
import { findTaskWorktree } from "../worktree-paths";
|
||||
import { findTaskAndProject } from "./task/shared";
|
||||
import { safeSendToRenderer } from "./utils";
|
||||
import { getClaudeProfileManager } from "../claude-profile-manager";
|
||||
|
||||
/**
|
||||
* Validates status transitions to prevent invalid state changes.
|
||||
* FIX (ACS-55, ACS-71): Adds guardrails against bad status transitions.
|
||||
* FIX (PR Review): Uses comprehensive wouldPhaseRegress() utility instead of hardcoded checks.
|
||||
* FIX (ACS-203): Adds phase completion validation to prevent phase overlaps.
|
||||
*
|
||||
* @param task - The current task (may be undefined if not found)
|
||||
* @param newStatus - The proposed new status
|
||||
* @param phase - The execution phase that triggered this transition
|
||||
* @returns true if transition is valid, false if it should be blocked
|
||||
*/
|
||||
function validateStatusTransition(
|
||||
task: Task | undefined,
|
||||
newStatus: TaskStatus,
|
||||
phase: string
|
||||
): boolean {
|
||||
// Can't validate without task data - allow the transition
|
||||
if (!task) return true;
|
||||
|
||||
// Don't allow human_review without subtasks
|
||||
// This prevents tasks from jumping to review before planning is complete
|
||||
if (newStatus === "human_review" && (!task.subtasks || task.subtasks.length === 0)) {
|
||||
console.warn(
|
||||
`[validateStatusTransition] Blocking human_review - task ${task.id} has no subtasks (phase: ${phase})`
|
||||
);
|
||||
return false;
|
||||
}
|
||||
|
||||
// FIX (PR Review): Use comprehensive phase regression check instead of hardcoded checks
|
||||
// This handles all phase regressions (qa_review→coding, complete→coding, etc.)
|
||||
// not just the specific coding→planning case
|
||||
const currentPhase = task.executionProgress?.phase;
|
||||
const completedPhases = task.executionProgress?.completedPhases || [];
|
||||
|
||||
if (currentPhase && isValidExecutionPhase(currentPhase) && isValidExecutionPhase(phase)) {
|
||||
// Block transitions from terminal phases (complete/failed)
|
||||
if (isTerminalPhase(currentPhase)) {
|
||||
console.warn(
|
||||
`[validateStatusTransition] Blocking transition from terminal phase: ${currentPhase} for task ${task.id}`
|
||||
);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Block any phase regression (going backwards in the workflow)
|
||||
// Note: Cast phase to ExecutionPhase since isValidExecutionPhase() type guard doesn't narrow through function calls
|
||||
if (wouldPhaseRegress(currentPhase, phase as ExecutionPhase)) {
|
||||
console.warn(
|
||||
`[validateStatusTransition] Blocking phase regression: ${currentPhase} -> ${phase} for task ${task.id}`
|
||||
);
|
||||
return false;
|
||||
}
|
||||
|
||||
// FIX (ACS-203): Validate phase transitions based on completed phases
|
||||
// This prevents multiple phases from being active simultaneously
|
||||
// e.g., coding starting while planning is still marked as active
|
||||
const newPhase = phase as ExecutionPhase;
|
||||
if (!isValidPhaseTransition(currentPhase, newPhase, completedPhases)) {
|
||||
console.warn(
|
||||
`[validateStatusTransition] Blocking invalid phase transition: ${currentPhase} -> ${newPhase} for task ${task.id}`,
|
||||
{
|
||||
currentPhase,
|
||||
newPhase,
|
||||
completedPhases,
|
||||
reason: "Prerequisite phases not completed",
|
||||
}
|
||||
);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
import { taskStateManager } from "../task-state-manager";
|
||||
|
||||
/**
|
||||
* Register all agent-events-related IPC handlers
|
||||
@@ -109,6 +26,8 @@ export function registerAgenteventsHandlers(
|
||||
agentManager: AgentManager,
|
||||
getMainWindow: () => BrowserWindow | null
|
||||
): void {
|
||||
taskStateManager.configure(getMainWindow);
|
||||
|
||||
// ============================================
|
||||
// Agent Manager Events → Renderer
|
||||
// ============================================
|
||||
@@ -164,10 +83,12 @@ export function registerAgenteventsHandlers(
|
||||
});
|
||||
|
||||
agentManager.on("exit", (taskId: string, code: number | null, processType: ProcessType) => {
|
||||
// Get project info early for multi-project filtering (issue #723)
|
||||
const { project: exitProject } = findTaskAndProject(taskId);
|
||||
// Get task + project for context and multi-project filtering (issue #723)
|
||||
const { task: exitTask, project: exitProject } = findTaskAndProject(taskId);
|
||||
const exitProjectId = exitProject?.id;
|
||||
|
||||
taskStateManager.handleProcessExited(taskId, code, exitTask, exitProject);
|
||||
|
||||
// Send final plan state to renderer BEFORE unwatching
|
||||
// This ensures the renderer has the final subtask data (fixes 0/0 subtask bug)
|
||||
const finalPlan = fileWatcher.getCurrentPlan(taskId);
|
||||
@@ -188,113 +109,70 @@ export function registerAgenteventsHandlers(
|
||||
return;
|
||||
}
|
||||
|
||||
let task: Task | undefined;
|
||||
let project: Project | undefined;
|
||||
const { task, project } = findTaskAndProject(taskId);
|
||||
if (!task || !project) return;
|
||||
|
||||
try {
|
||||
const projects = projectStore.getProjects();
|
||||
const taskTitle = task.title || task.specId;
|
||||
if (code === 0) {
|
||||
notificationService.notifyReviewNeeded(taskTitle, project.id, taskId);
|
||||
} else {
|
||||
notificationService.notifyTaskFailed(taskTitle, project.id, taskId);
|
||||
}
|
||||
});
|
||||
|
||||
// IMPORTANT: Invalidate cache for all projects to ensure we get fresh data
|
||||
// This prevents race conditions where cached task data has stale status
|
||||
for (const p of projects) {
|
||||
projectStore.invalidateTasksCache(p.id);
|
||||
}
|
||||
|
||||
for (const p of projects) {
|
||||
const tasks = projectStore.getTasks(p.id);
|
||||
task = tasks.find((t) => t.id === taskId || t.specId === taskId);
|
||||
if (task) {
|
||||
project = p;
|
||||
break;
|
||||
}
|
||||
}
|
||||
agentManager.on("task-event", (taskId: string, event) => {
|
||||
console.log(`[agent-events-handlers] Received task-event for ${taskId}:`, event.type, event);
|
||||
|
||||
if (taskStateManager.getLastSequence(taskId) === undefined) {
|
||||
const { task, project } = findTaskAndProject(taskId);
|
||||
if (task && project) {
|
||||
const taskTitle = task.title || task.specId;
|
||||
const mainPlanPath = getPlanPath(project, task);
|
||||
const projectId = project.id; // Capture for closure
|
||||
|
||||
// Capture task values for closure
|
||||
const taskSpecId = task.specId;
|
||||
const projectPath = project.path;
|
||||
const autoBuildPath = project.autoBuildPath;
|
||||
|
||||
// Use shared utility for persisting status (prevents race conditions)
|
||||
// Persist to both main project AND worktree (if exists) for consistency
|
||||
const persistStatus = (status: TaskStatus) => {
|
||||
// Persist to main project
|
||||
const mainPersisted = persistPlanStatusSync(mainPlanPath, status, projectId);
|
||||
if (mainPersisted) {
|
||||
console.warn(`[Task ${taskId}] Persisted status to main plan: ${status}`);
|
||||
try {
|
||||
const planPath = getPlanPath(project, task);
|
||||
const planContent = readFileSync(planPath, "utf-8");
|
||||
const plan = JSON.parse(planContent);
|
||||
const lastSeq = plan?.lastEvent?.sequence;
|
||||
if (typeof lastSeq === "number" && lastSeq >= 0) {
|
||||
taskStateManager.setLastSequence(taskId, lastSeq);
|
||||
}
|
||||
|
||||
// Also persist to worktree if it exists
|
||||
const worktreePath = findTaskWorktree(projectPath, taskSpecId);
|
||||
if (worktreePath) {
|
||||
const specsBaseDir = getSpecsDir(autoBuildPath);
|
||||
const worktreePlanPath = path.join(
|
||||
worktreePath,
|
||||
specsBaseDir,
|
||||
taskSpecId,
|
||||
AUTO_BUILD_PATHS.IMPLEMENTATION_PLAN
|
||||
);
|
||||
if (existsSync(worktreePlanPath)) {
|
||||
const worktreePersisted = persistPlanStatusSync(worktreePlanPath, status, projectId);
|
||||
if (worktreePersisted) {
|
||||
console.warn(`[Task ${taskId}] Persisted status to worktree plan: ${status}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
if (code === 0) {
|
||||
notificationService.notifyReviewNeeded(taskTitle, project.id, taskId);
|
||||
|
||||
// Fallback: Ensure status is updated even if COMPLETE phase event was missed
|
||||
// This prevents tasks from getting stuck in ai_review status
|
||||
// FIX (ACS-71): Only move to human_review if subtasks exist AND are all completed
|
||||
// If no subtasks exist, the task is still in planning and shouldn't move to human_review
|
||||
const isActiveStatus = task.status === "in_progress" || task.status === "ai_review";
|
||||
const hasSubtasks = task.subtasks && task.subtasks.length > 0;
|
||||
const hasIncompleteSubtasks =
|
||||
hasSubtasks && task.subtasks.some((s) => s.status !== "completed");
|
||||
|
||||
if (isActiveStatus && hasSubtasks && !hasIncompleteSubtasks) {
|
||||
// All subtasks completed - safe to move to human_review
|
||||
console.warn(
|
||||
`[Task ${taskId}] Fallback: Moving to human_review (process exited successfully, all ${task.subtasks.length} subtasks completed)`
|
||||
);
|
||||
persistStatus("human_review");
|
||||
// Include projectId for multi-project filtering (issue #723)
|
||||
safeSendToRenderer(
|
||||
getMainWindow,
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
"human_review" as TaskStatus,
|
||||
projectId
|
||||
);
|
||||
} else if (isActiveStatus && !hasSubtasks) {
|
||||
// No subtasks yet - task is still in planning phase, don't change status
|
||||
// This prevents the bug where tasks jump to human_review before planning completes
|
||||
console.warn(
|
||||
`[Task ${taskId}] Process exited but no subtasks created yet - keeping current status (${task.status})`
|
||||
);
|
||||
}
|
||||
} else {
|
||||
notificationService.notifyTaskFailed(taskTitle, project.id, taskId);
|
||||
persistStatus("human_review");
|
||||
// Include projectId for multi-project filtering (issue #723)
|
||||
safeSendToRenderer(
|
||||
getMainWindow,
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
"human_review" as TaskStatus,
|
||||
projectId
|
||||
);
|
||||
} catch {
|
||||
// Ignore missing/invalid plan files
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(`[Task ${taskId}] Exit handler error:`, error);
|
||||
}
|
||||
|
||||
const { task, project } = findTaskAndProject(taskId);
|
||||
if (!task || !project) {
|
||||
console.log(`[agent-events-handlers] No task/project found for ${taskId}`);
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`[agent-events-handlers] Task state before handleTaskEvent:`, {
|
||||
status: task.status,
|
||||
reviewReason: task.reviewReason,
|
||||
phase: task.executionProgress?.phase
|
||||
});
|
||||
|
||||
const accepted = taskStateManager.handleTaskEvent(taskId, event, task, project);
|
||||
console.log(`[agent-events-handlers] Event ${event.type} accepted: ${accepted}`);
|
||||
if (!accepted) {
|
||||
return;
|
||||
}
|
||||
|
||||
const mainPlanPath = getPlanPath(project, task);
|
||||
persistPlanLastEventSync(mainPlanPath, event);
|
||||
|
||||
const worktreePath = findTaskWorktree(project.path, task.specId);
|
||||
if (worktreePath) {
|
||||
const specsBaseDir = getSpecsDir(project.autoBuildPath);
|
||||
const worktreePlanPath = path.join(
|
||||
worktreePath,
|
||||
specsBaseDir,
|
||||
task.specId,
|
||||
AUTO_BUILD_PATHS.IMPLEMENTATION_PLAN
|
||||
);
|
||||
if (existsSync(worktreePlanPath)) {
|
||||
persistPlanLastEventSync(worktreePlanPath, event);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
@@ -303,6 +181,28 @@ export function registerAgenteventsHandlers(
|
||||
const { task, project } = findTaskAndProject(taskId);
|
||||
const taskProjectId = project?.id;
|
||||
|
||||
// Persist phase to plan file for restoration on app refresh
|
||||
// Must persist to BOTH main project and worktree (if exists) since task may be loaded from either
|
||||
if (task && project && progress.phase) {
|
||||
const mainPlanPath = getPlanPath(project, task);
|
||||
persistPlanPhaseSync(mainPlanPath, progress.phase, project.id);
|
||||
|
||||
// Also persist to worktree if task has one
|
||||
const worktreePath = findTaskWorktree(project.path, task.specId);
|
||||
if (worktreePath) {
|
||||
const specsBaseDir = getSpecsDir(project.autoBuildPath);
|
||||
const worktreePlanPath = path.join(
|
||||
worktreePath,
|
||||
specsBaseDir,
|
||||
task.specId,
|
||||
AUTO_BUILD_PATHS.IMPLEMENTATION_PLAN
|
||||
);
|
||||
if (existsSync(worktreePlanPath)) {
|
||||
persistPlanPhaseSync(worktreePlanPath, progress.phase, project.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Include projectId in execution progress event for multi-project filtering
|
||||
safeSendToRenderer(
|
||||
getMainWindow,
|
||||
@@ -311,62 +211,6 @@ export function registerAgenteventsHandlers(
|
||||
progress,
|
||||
taskProjectId
|
||||
);
|
||||
|
||||
const phaseToStatus: Record<string, TaskStatus | null> = {
|
||||
idle: null,
|
||||
planning: "in_progress",
|
||||
coding: "in_progress",
|
||||
qa_review: "ai_review",
|
||||
qa_fixing: "ai_review",
|
||||
complete: "human_review",
|
||||
failed: "human_review",
|
||||
};
|
||||
|
||||
const newStatus = phaseToStatus[progress.phase];
|
||||
// FIX (ACS-55, ACS-71): Validate status transition before sending/persisting
|
||||
if (newStatus && validateStatusTransition(task, newStatus, progress.phase)) {
|
||||
// Include projectId in status change event for multi-project filtering
|
||||
safeSendToRenderer(
|
||||
getMainWindow,
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
newStatus,
|
||||
taskProjectId
|
||||
);
|
||||
|
||||
// CRITICAL: Persist status to plan file(s) to prevent flip-flop on task list refresh
|
||||
// When getTasks() is called, it reads status from the plan file. Without persisting,
|
||||
// the status in the file might differ from the UI, causing inconsistent state.
|
||||
// Uses shared utility with locking to prevent race conditions.
|
||||
// IMPORTANT: We persist to BOTH main project AND worktree (if exists) to ensure
|
||||
// consistency, since getTasks() prefers the worktree version.
|
||||
if (task && project) {
|
||||
try {
|
||||
// Persist to main project plan file
|
||||
const mainPlanPath = getPlanPath(project, task);
|
||||
persistPlanStatusSync(mainPlanPath, newStatus, project.id);
|
||||
|
||||
// Also persist to worktree plan file if it exists
|
||||
// This ensures consistency since getTasks() prefers worktree version
|
||||
const worktreePath = findTaskWorktree(project.path, task.specId);
|
||||
if (worktreePath) {
|
||||
const specsBaseDir = getSpecsDir(project.autoBuildPath);
|
||||
const worktreePlanPath = path.join(
|
||||
worktreePath,
|
||||
specsBaseDir,
|
||||
task.specId,
|
||||
AUTO_BUILD_PATHS.IMPLEMENTATION_PLAN
|
||||
);
|
||||
if (existsSync(worktreePlanPath)) {
|
||||
persistPlanStatusSync(worktreePlanPath, newStatus, project.id);
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
// Ignore persistence errors - UI will still work, just might flip on refresh
|
||||
console.warn("[execution-progress] Could not persist status:", err);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// ============================================
|
||||
|
||||
@@ -10,6 +10,7 @@ import { findTaskAndProject } from './shared';
|
||||
import { findAllSpecPaths, isValidTaskId } from '../../utils/spec-path-helpers';
|
||||
import { isPathWithinBase, findTaskWorktree } from '../../worktree-paths';
|
||||
import { cleanupWorktree } from '../../utils/worktree-cleanup';
|
||||
import { taskStateManager } from '../../task-state-manager';
|
||||
|
||||
/**
|
||||
* Register task CRUD (Create, Read, Update, Delete) handlers
|
||||
@@ -26,11 +27,13 @@ export function registerTaskCRUDHandlers(agentManager: AgentManager): void {
|
||||
async (_, projectId: string, options?: { forceRefresh?: boolean }): Promise<IPCResult<Task[]>> => {
|
||||
console.warn('[IPC] TASK_LIST called with projectId:', projectId, 'options:', options);
|
||||
|
||||
// If forceRefresh is requested, invalidate cache first
|
||||
// If forceRefresh is requested, invalidate cache and clear XState actors
|
||||
// This ensures the refresh button always returns fresh data from disk
|
||||
// and actors are recreated with fresh task data
|
||||
if (options?.forceRefresh) {
|
||||
projectStore.invalidateTasksCache(projectId);
|
||||
console.warn('[IPC] TASK_LIST cache invalidated for forceRefresh');
|
||||
taskStateManager.clearAllTasks();
|
||||
console.warn('[IPC] TASK_LIST cache and task state cleared for forceRefresh');
|
||||
}
|
||||
|
||||
const tasks = projectStore.getTasks(projectId);
|
||||
@@ -125,28 +128,52 @@ export function registerTaskCRUDHandlers(agentManager: AgentManager): void {
|
||||
if (taskMetadata.attachedImages && taskMetadata.attachedImages.length > 0) {
|
||||
const attachmentsDir = path.join(specDir, 'attachments');
|
||||
mkdirSync(attachmentsDir, { recursive: true });
|
||||
const resolvedAttachmentsDir = path.resolve(attachmentsDir);
|
||||
|
||||
// MIME type allowlist (defense in depth - frontend also validates)
|
||||
const ALLOWED_MIME_TYPES = ['image/png', 'image/jpeg', 'image/jpg', 'image/gif', 'image/webp', 'image/svg+xml'];
|
||||
|
||||
const savedImages: typeof taskMetadata.attachedImages = [];
|
||||
|
||||
for (const image of taskMetadata.attachedImages) {
|
||||
if (image.data) {
|
||||
// Validate MIME type
|
||||
if (!image.mimeType || !ALLOWED_MIME_TYPES.includes(image.mimeType)) {
|
||||
console.warn(`[TASK_CREATE] Skipping image with missing or disallowed MIME type: ${image.mimeType}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Sanitize filename to prevent path traversal attacks
|
||||
const sanitizedFilename = path.basename(image.filename);
|
||||
if (!sanitizedFilename || sanitizedFilename === '.' || sanitizedFilename === '..') {
|
||||
console.warn(`[TASK_CREATE] Skipping image with invalid filename: ${image.filename}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Validate resolved path stays within attachments directory
|
||||
const imagePath = path.join(attachmentsDir, sanitizedFilename);
|
||||
const resolvedPath = path.resolve(imagePath);
|
||||
if (!resolvedPath.startsWith(resolvedAttachmentsDir + path.sep)) {
|
||||
console.warn(`[TASK_CREATE] Skipping image with path traversal attempt: ${image.filename}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
try {
|
||||
// Decode base64 and save to file
|
||||
const buffer = Buffer.from(image.data, 'base64');
|
||||
const imagePath = path.join(attachmentsDir, image.filename);
|
||||
writeFileSync(imagePath, buffer);
|
||||
|
||||
// Store relative path instead of base64 data
|
||||
savedImages.push({
|
||||
id: image.id,
|
||||
filename: image.filename,
|
||||
filename: sanitizedFilename,
|
||||
mimeType: image.mimeType,
|
||||
size: image.size,
|
||||
path: `attachments/${image.filename}`
|
||||
path: `attachments/${sanitizedFilename}`
|
||||
// Don't include data or thumbnail to save space
|
||||
});
|
||||
} catch (err) {
|
||||
console.error(`Failed to save image ${image.filename}:`, err);
|
||||
console.error(`Failed to save image ${sanitizedFilename}:`, err);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -428,26 +455,50 @@ export function registerTaskCRUDHandlers(agentManager: AgentManager): void {
|
||||
if (updates.metadata.attachedImages && updates.metadata.attachedImages.length > 0) {
|
||||
const attachmentsDir = path.join(specDir, 'attachments');
|
||||
mkdirSync(attachmentsDir, { recursive: true });
|
||||
const resolvedAttachmentsDir = path.resolve(attachmentsDir);
|
||||
|
||||
// MIME type allowlist (defense in depth - frontend also validates)
|
||||
const ALLOWED_MIME_TYPES = ['image/png', 'image/jpeg', 'image/jpg', 'image/gif', 'image/webp', 'image/svg+xml'];
|
||||
|
||||
const savedImages: typeof updates.metadata.attachedImages = [];
|
||||
|
||||
for (const image of updates.metadata.attachedImages) {
|
||||
// If image has data (new image), save it
|
||||
if (image.data) {
|
||||
// Validate MIME type
|
||||
if (!image.mimeType || !ALLOWED_MIME_TYPES.includes(image.mimeType)) {
|
||||
console.warn(`[TASK_UPDATE] Skipping image with missing or disallowed MIME type: ${image.mimeType}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Sanitize filename to prevent path traversal attacks
|
||||
const sanitizedFilename = path.basename(image.filename);
|
||||
if (!sanitizedFilename || sanitizedFilename === '.' || sanitizedFilename === '..') {
|
||||
console.warn(`[TASK_UPDATE] Skipping image with invalid filename: ${image.filename}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Validate resolved path stays within attachments directory
|
||||
const imagePath = path.join(attachmentsDir, sanitizedFilename);
|
||||
const resolvedPath = path.resolve(imagePath);
|
||||
if (!resolvedPath.startsWith(resolvedAttachmentsDir + path.sep)) {
|
||||
console.warn(`[TASK_UPDATE] Skipping image with path traversal attempt: ${image.filename}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
try {
|
||||
const buffer = Buffer.from(image.data, 'base64');
|
||||
const imagePath = path.join(attachmentsDir, image.filename);
|
||||
writeFileSync(imagePath, buffer);
|
||||
|
||||
savedImages.push({
|
||||
id: image.id,
|
||||
filename: image.filename,
|
||||
filename: sanitizedFilename,
|
||||
mimeType: image.mimeType,
|
||||
size: image.size,
|
||||
path: `attachments/${image.filename}`
|
||||
path: `attachments/${sanitizedFilename}`
|
||||
});
|
||||
} catch (err) {
|
||||
console.error(`Failed to save image ${image.filename}:`, err);
|
||||
console.error(`Failed to save image ${sanitizedFilename}:`, err);
|
||||
}
|
||||
} else if (image.path) {
|
||||
// Existing image, keep it
|
||||
|
||||
@@ -10,6 +10,7 @@ import { fileWatcher } from '../../file-watcher';
|
||||
import { findTaskAndProject } from './shared';
|
||||
import { checkGitStatus } from '../../project-initializer';
|
||||
import { initializeClaudeProfileManager, type ClaudeProfileManager } from '../../claude-profile-manager';
|
||||
import { taskStateManager } from '../../task-state-manager';
|
||||
import {
|
||||
getPlanPath,
|
||||
persistPlanStatus,
|
||||
@@ -177,7 +178,42 @@ export function registerTaskExecutionHandlers(
|
||||
return;
|
||||
}
|
||||
|
||||
console.warn('[TASK_START] Found task:', task.specId, 'status:', task.status, 'subtasks:', task.subtasks.length);
|
||||
console.warn('[TASK_START] Found task:', task.specId, 'status:', task.status, 'reviewReason:', task.reviewReason, 'subtasks:', task.subtasks.length);
|
||||
|
||||
// Immediately mark as started so the UI moves the card to In Progress.
|
||||
// Use XState actor state as source of truth (if actor exists), with task data as fallback.
|
||||
// - plan_review: User approved the plan, send PLAN_APPROVED to transition to coding
|
||||
// - human_review/error: User resuming, send USER_RESUMED
|
||||
// - backlog/other: Fresh start, send PLANNING_STARTED
|
||||
const currentXState = taskStateManager.getCurrentState(taskId);
|
||||
console.warn('[TASK_START] Current XState:', currentXState, '| Task status:', task.status, task.reviewReason);
|
||||
|
||||
if (currentXState === 'plan_review') {
|
||||
// XState says plan_review - send PLAN_APPROVED
|
||||
console.warn('[TASK_START] XState: plan_review -> coding via PLAN_APPROVED');
|
||||
taskStateManager.handleUiEvent(taskId, { type: 'PLAN_APPROVED' }, task, project);
|
||||
} else if (currentXState === 'human_review' || currentXState === 'error') {
|
||||
// XState says human_review or error - send USER_RESUMED
|
||||
console.warn('[TASK_START] XState:', currentXState, '-> coding via USER_RESUMED');
|
||||
taskStateManager.handleUiEvent(taskId, { type: 'USER_RESUMED' }, task, project);
|
||||
} else if (currentXState) {
|
||||
// XState actor exists but in another state (coding, planning, etc.)
|
||||
// This shouldn't happen normally, but handle gracefully
|
||||
console.warn('[TASK_START] XState in unexpected state:', currentXState, '- sending PLANNING_STARTED');
|
||||
taskStateManager.handleUiEvent(taskId, { type: 'PLANNING_STARTED' }, task, project);
|
||||
} else if (task.status === 'human_review' && task.reviewReason === 'plan_review') {
|
||||
// No XState actor - fallback to task data (e.g., after app restart)
|
||||
console.warn('[TASK_START] No XState actor, task data: plan_review -> coding via PLAN_APPROVED');
|
||||
taskStateManager.handleUiEvent(taskId, { type: 'PLAN_APPROVED' }, task, project);
|
||||
} else if (task.status === 'human_review' || task.status === 'error') {
|
||||
// No XState actor - fallback to task data for resuming
|
||||
console.warn('[TASK_START] No XState actor, task data:', task.status, '-> coding via USER_RESUMED');
|
||||
taskStateManager.handleUiEvent(taskId, { type: 'USER_RESUMED' }, task, project);
|
||||
} else {
|
||||
// Fresh start - PLANNING_STARTED transitions from backlog to planning
|
||||
console.warn('[TASK_START] Fresh start via PLANNING_STARTED');
|
||||
taskStateManager.handleUiEvent(taskId, { type: 'PLANNING_STARTED' }, task, project);
|
||||
}
|
||||
|
||||
// Start file watcher for this task
|
||||
const specsBaseDir = getSpecsDir(project.autoBuildPath);
|
||||
@@ -252,45 +288,6 @@ export function registerTaskExecutionHandlers(
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
// Notify status change IMMEDIATELY (don't wait for file write)
|
||||
// This provides instant UI feedback while file persistence happens in background
|
||||
const ipcSentAt = Date.now();
|
||||
mainWindow.webContents.send(
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
'in_progress'
|
||||
);
|
||||
|
||||
const DEBUG = process.env.DEBUG === 'true';
|
||||
if (DEBUG) {
|
||||
console.log(`[TASK_START] IPC sent immediately for task ${taskId}, deferring file persistence`);
|
||||
}
|
||||
|
||||
// CRITICAL: Persist status to implementation_plan.json to prevent status flip-flop
|
||||
// When getTasks() is called (on refresh), it reads status from the plan file.
|
||||
// Without persisting here, the old status (e.g., 'human_review') would override
|
||||
// the in-memory 'in_progress' status, causing the task to flip back and forth.
|
||||
// Uses shared utility for consistency with agent-events-handlers.ts
|
||||
// NOTE: This is now async and non-blocking for better UI responsiveness
|
||||
const planPath = path.join(specDir, AUTO_BUILD_PATHS.IMPLEMENTATION_PLAN);
|
||||
setImmediate(async () => {
|
||||
const persistStart = Date.now();
|
||||
try {
|
||||
const persisted = await persistPlanStatus(planPath, 'in_progress', project.id);
|
||||
if (persisted) {
|
||||
console.warn('[TASK_START] Updated plan status to: in_progress');
|
||||
}
|
||||
if (DEBUG) {
|
||||
const delay = persistStart - ipcSentAt;
|
||||
const duration = Date.now() - persistStart;
|
||||
console.log(`[TASK_START] File persistence: delayed ${delay}ms after IPC, completed in ${duration}ms`);
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('[TASK_START] Failed to persist plan status:', err);
|
||||
}
|
||||
});
|
||||
// Note: Plan file may not exist yet for new tasks - that's fine (persistPlanStatus handles ENOENT)
|
||||
}
|
||||
);
|
||||
|
||||
@@ -298,52 +295,33 @@ export function registerTaskExecutionHandlers(
|
||||
* Stop a task
|
||||
*/
|
||||
ipcMain.on(IPC_CHANNELS.TASK_STOP, (_, taskId: string) => {
|
||||
const DEBUG = process.env.DEBUG === 'true';
|
||||
|
||||
agentManager.killTask(taskId);
|
||||
fileWatcher.unwatch(taskId);
|
||||
|
||||
// Notify status change IMMEDIATELY for instant UI feedback
|
||||
const ipcSentAt = Date.now();
|
||||
const mainWindow = getMainWindow();
|
||||
if (mainWindow) {
|
||||
mainWindow.webContents.send(
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
'backlog'
|
||||
);
|
||||
}
|
||||
|
||||
if (DEBUG) {
|
||||
console.log(`[TASK_STOP] IPC sent immediately for task ${taskId}, deferring file persistence`);
|
||||
}
|
||||
|
||||
// Find task and project to update the plan file (async, non-blocking)
|
||||
// Find task and project to emit USER_STOPPED with plan context
|
||||
const { task, project } = findTaskAndProject(taskId);
|
||||
|
||||
if (task && project) {
|
||||
// Persist status to implementation_plan.json to prevent status flip-flop on refresh
|
||||
// Uses shared utility for consistency with agent-events-handlers.ts
|
||||
// NOTE: This is now async and non-blocking for better UI responsiveness
|
||||
if (!task || !project) return;
|
||||
|
||||
let hasPlan = false;
|
||||
try {
|
||||
const planPath = getPlanPath(project, task);
|
||||
setImmediate(async () => {
|
||||
const persistStart = Date.now();
|
||||
try {
|
||||
const persisted = await persistPlanStatus(planPath, 'backlog', project.id);
|
||||
if (persisted) {
|
||||
console.warn('[TASK_STOP] Updated plan status to backlog');
|
||||
}
|
||||
if (DEBUG) {
|
||||
const delay = persistStart - ipcSentAt;
|
||||
const duration = Date.now() - persistStart;
|
||||
console.log(`[TASK_STOP] File persistence: delayed ${delay}ms after IPC, completed in ${duration}ms`);
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('[TASK_STOP] Failed to persist plan status:', err);
|
||||
}
|
||||
});
|
||||
// Note: File not found is expected for tasks without a plan file (persistPlanStatus handles ENOENT)
|
||||
const planContent = safeReadFileSync(planPath);
|
||||
if (planContent) {
|
||||
const plan = JSON.parse(planContent);
|
||||
const { totalCount } = checkSubtasksCompletion(plan);
|
||||
hasPlan = totalCount > 0;
|
||||
}
|
||||
} catch {
|
||||
hasPlan = false;
|
||||
}
|
||||
|
||||
taskStateManager.handleUiEvent(
|
||||
taskId,
|
||||
{ type: 'USER_STOPPED', hasPlan },
|
||||
task,
|
||||
project
|
||||
);
|
||||
});
|
||||
|
||||
/**
|
||||
@@ -392,29 +370,12 @@ export function registerTaskExecutionHandlers(
|
||||
return { success: false, error: 'Failed to write QA report file' };
|
||||
}
|
||||
|
||||
// Notify UI immediately for instant feedback
|
||||
const mainWindow = getMainWindow();
|
||||
if (mainWindow) {
|
||||
mainWindow.webContents.send(
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
'done'
|
||||
);
|
||||
}
|
||||
|
||||
// CRITICAL: Persist 'done' status to implementation_plan.json
|
||||
// Without this, the old status would be shown after page refresh since
|
||||
// getTasks() reads status from the plan file, not from the Zustand store.
|
||||
const planPath = getPlanPath(project, task);
|
||||
try {
|
||||
const persisted = await persistPlanStatus(planPath, 'done', project.id);
|
||||
if (persisted) {
|
||||
console.warn('[TASK_REVIEW] Persisted approved status (done) to implementation_plan.json');
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('[TASK_REVIEW] Failed to persist approved status:', err);
|
||||
// Non-fatal: UI already updated, file persistence is best-effort
|
||||
}
|
||||
taskStateManager.handleUiEvent(
|
||||
taskId,
|
||||
{ type: 'MARK_DONE' },
|
||||
task,
|
||||
project
|
||||
);
|
||||
} else {
|
||||
// Reset and discard all changes from worktree merge in main
|
||||
// The worktree still has all changes, so nothing is lost
|
||||
@@ -536,29 +497,12 @@ export function registerTaskExecutionHandlers(
|
||||
console.warn('[TASK_REVIEW] Starting QA process with projectPath:', qaProjectPath);
|
||||
agentManager.startQAProcess(taskId, qaProjectPath, task.specId);
|
||||
|
||||
// Notify UI immediately for instant feedback
|
||||
const mainWindow = getMainWindow();
|
||||
if (mainWindow) {
|
||||
mainWindow.webContents.send(
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
'in_progress'
|
||||
);
|
||||
}
|
||||
|
||||
// CRITICAL: Persist 'in_progress' status to implementation_plan.json
|
||||
// Without this, the old status (e.g., 'human_review') would be shown after page refresh
|
||||
// since getTasks() reads status from the plan file, not from the Zustand store.
|
||||
const planPath = getPlanPath(project, task);
|
||||
try {
|
||||
const persisted = await persistPlanStatus(planPath, 'in_progress', project.id);
|
||||
if (persisted) {
|
||||
console.warn('[TASK_REVIEW] Persisted rejected status (in_progress) to implementation_plan.json');
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('[TASK_REVIEW] Failed to persist rejected status:', err);
|
||||
// Non-fatal: UI already updated, file persistence is best-effort
|
||||
}
|
||||
taskStateManager.handleUiEvent(
|
||||
taskId,
|
||||
{ type: 'USER_RESUMED' },
|
||||
task,
|
||||
project
|
||||
);
|
||||
}
|
||||
|
||||
return { success: true };
|
||||
@@ -699,14 +643,17 @@ export function registerTaskExecutionHandlers(
|
||||
const planPath = getPlanPath(project, task);
|
||||
|
||||
try {
|
||||
// Use shared utility for thread-safe plan file updates
|
||||
const persisted = await persistPlanStatus(planPath, status, project.id);
|
||||
const handledByMachine = taskStateManager.handleManualStatusChange(taskId, status, task, project);
|
||||
if (!handledByMachine) {
|
||||
// Use shared utility for thread-safe plan file updates (legacy/manual override)
|
||||
const persisted = await persistPlanStatus(planPath, status, project.id);
|
||||
|
||||
if (!persisted) {
|
||||
// If no implementation plan exists yet, create a basic one
|
||||
await createPlanIfNotExists(planPath, task, status);
|
||||
// Invalidate cache after creating new plan
|
||||
projectStore.invalidateTasksCache(project.id);
|
||||
if (!persisted) {
|
||||
// If no implementation plan exists yet, create a basic one
|
||||
await createPlanIfNotExists(planPath, task, status);
|
||||
// Invalidate cache after creating new plan
|
||||
projectStore.invalidateTasksCache(project.id);
|
||||
}
|
||||
}
|
||||
|
||||
// Auto-stop task when status changes AWAY from 'in_progress' and process IS running
|
||||
@@ -817,7 +764,8 @@ export function registerTaskExecutionHandlers(
|
||||
mainWindow.webContents.send(
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
'in_progress'
|
||||
'in_progress',
|
||||
project.id
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1191,7 +1139,8 @@ export function registerTaskExecutionHandlers(
|
||||
mainWindow.webContents.send(
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
newStatus
|
||||
newStatus,
|
||||
project.id
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -22,6 +22,7 @@ import { readFileSync, writeFileSync, mkdirSync } from 'fs';
|
||||
import { AUTO_BUILD_PATHS, getSpecsDir } from '../../../shared/constants';
|
||||
import type { TaskStatus, Project, Task } from '../../../shared/types';
|
||||
import { projectStore } from '../../project-store';
|
||||
import type { TaskEventPayload } from '../../agent/task-event-schema';
|
||||
|
||||
// In-memory locks for plan file operations
|
||||
// Key: plan file path, Value: Promise chain for serializing operations
|
||||
@@ -185,6 +186,160 @@ export function persistPlanStatusSync(planPath: string, status: TaskStatus, proj
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Persist lastEvent metadata synchronously.
|
||||
*
|
||||
* WARNING: This bypasses async locking. Use only in sync event handlers where
|
||||
* async isn't practical. Prefer updatePlanFile when possible.
|
||||
*/
|
||||
export function persistPlanLastEventSync(planPath: string, event: TaskEventPayload): boolean {
|
||||
try {
|
||||
const planContent = readFileSync(planPath, 'utf-8');
|
||||
const plan = JSON.parse(planContent);
|
||||
|
||||
plan.lastEvent = {
|
||||
eventId: event.eventId,
|
||||
sequence: event.sequence,
|
||||
type: event.type,
|
||||
timestamp: event.timestamp
|
||||
};
|
||||
plan.updated_at = new Date().toISOString();
|
||||
|
||||
writeFileSync(planPath, JSON.stringify(plan, null, 2), 'utf-8');
|
||||
return true;
|
||||
} catch (err) {
|
||||
if (isFileNotFoundError(err)) {
|
||||
return false;
|
||||
}
|
||||
console.warn(`[plan-file-utils] Could not persist lastEvent to ${planPath}:`, err);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Persist task status, reviewReason, XState state, and execution phase synchronously.
|
||||
* The xstateState and executionPhase are used to restore the exact machine state on reload,
|
||||
* distinguishing between e.g. 'planning' vs 'coding' when both have status 'in_progress'.
|
||||
*
|
||||
* If the plan file doesn't exist, creates a minimal plan with the status fields.
|
||||
* This ensures XState state is persisted even during early phases like spec creation.
|
||||
*/
|
||||
export function persistPlanStatusAndReasonSync(
|
||||
planPath: string,
|
||||
status: TaskStatus,
|
||||
reviewReason?: string,
|
||||
projectId?: string,
|
||||
xstateState?: string,
|
||||
executionPhase?: string
|
||||
): boolean {
|
||||
try {
|
||||
let plan: Record<string, unknown>;
|
||||
|
||||
try {
|
||||
const planContent = readFileSync(planPath, 'utf-8');
|
||||
plan = JSON.parse(planContent);
|
||||
} catch (readErr) {
|
||||
if (!isFileNotFoundError(readErr)) {
|
||||
throw readErr;
|
||||
}
|
||||
// File doesn't exist - create a minimal plan with just status fields
|
||||
// The spec runner will populate the full plan later
|
||||
const planDir = path.dirname(planPath);
|
||||
mkdirSync(planDir, { recursive: true });
|
||||
plan = {
|
||||
created_at: new Date().toISOString(),
|
||||
phases: []
|
||||
};
|
||||
console.log(`[plan-file-utils] Creating minimal plan for XState persistence: ${planPath}`);
|
||||
}
|
||||
|
||||
plan.status = status;
|
||||
plan.planStatus = mapStatusToPlanStatus(status);
|
||||
plan.reviewReason = reviewReason;
|
||||
if (xstateState) {
|
||||
plan.xstateState = xstateState;
|
||||
}
|
||||
if (executionPhase) {
|
||||
plan.executionPhase = executionPhase;
|
||||
}
|
||||
plan.updated_at = new Date().toISOString();
|
||||
|
||||
writeFileSync(planPath, JSON.stringify(plan, null, 2), 'utf-8');
|
||||
|
||||
if (projectId) {
|
||||
projectStore.invalidateTasksCache(projectId);
|
||||
}
|
||||
|
||||
return true;
|
||||
} catch (err) {
|
||||
console.warn(`[plan-file-utils] Could not persist status/reason to ${planPath}:`, err);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Persist execution phase to the plan file synchronously.
|
||||
* This is called when execution progress updates to ensure the phase
|
||||
* is persisted for restoration on app refresh.
|
||||
*/
|
||||
export function persistPlanPhaseSync(
|
||||
planPath: string,
|
||||
phase: string,
|
||||
projectId?: string
|
||||
): boolean {
|
||||
try {
|
||||
let plan: Record<string, unknown>;
|
||||
|
||||
try {
|
||||
const planContent = readFileSync(planPath, 'utf-8');
|
||||
plan = JSON.parse(planContent);
|
||||
} catch (readErr) {
|
||||
if (!isFileNotFoundError(readErr)) {
|
||||
throw readErr;
|
||||
}
|
||||
// File doesn't exist - create minimal plan
|
||||
const planDir = path.dirname(planPath);
|
||||
mkdirSync(planDir, { recursive: true });
|
||||
plan = {
|
||||
created_at: new Date().toISOString(),
|
||||
phases: []
|
||||
};
|
||||
}
|
||||
|
||||
// Store the execution phase for restoration
|
||||
plan.executionPhase = phase;
|
||||
|
||||
// Also update status to match the phase so the card stays in the correct column on refresh
|
||||
// Map execution phase to TaskStatus for column placement
|
||||
const phaseToStatus: Record<string, TaskStatus> = {
|
||||
'planning': 'in_progress',
|
||||
'coding': 'in_progress',
|
||||
'qa_review': 'in_progress',
|
||||
'qa_fixing': 'in_progress',
|
||||
'complete': 'human_review',
|
||||
'failed': 'error'
|
||||
};
|
||||
const mappedStatus = phaseToStatus[phase];
|
||||
if (mappedStatus) {
|
||||
plan.status = mappedStatus;
|
||||
plan.planStatus = mapStatusToPlanStatus(mappedStatus);
|
||||
}
|
||||
|
||||
plan.updated_at = new Date().toISOString();
|
||||
|
||||
writeFileSync(planPath, JSON.stringify(plan, null, 2), 'utf-8');
|
||||
|
||||
if (projectId) {
|
||||
projectStore.invalidateTasksCache(projectId);
|
||||
}
|
||||
|
||||
return true;
|
||||
} catch (err) {
|
||||
console.warn(`[plan-file-utils] Could not persist phase to ${planPath}:`, err);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read and update the plan file atomically.
|
||||
*
|
||||
@@ -228,11 +383,13 @@ export async function updatePlanFile<T extends Record<string, unknown>>(
|
||||
* @param planPath - Path to the implementation_plan.json file
|
||||
* @param task - The task to create the plan for
|
||||
* @param status - Initial status for the plan
|
||||
* @param xstateState - Optional XState machine state for restoration
|
||||
*/
|
||||
export async function createPlanIfNotExists(
|
||||
planPath: string,
|
||||
task: Task,
|
||||
status: TaskStatus
|
||||
status: TaskStatus,
|
||||
xstateState?: string
|
||||
): Promise<void> {
|
||||
return withPlanLock(planPath, async () => {
|
||||
// Try to read the file first - if it exists, do nothing
|
||||
@@ -246,7 +403,7 @@ export async function createPlanIfNotExists(
|
||||
// File doesn't exist, continue to create it
|
||||
}
|
||||
|
||||
const plan = {
|
||||
const plan: Record<string, unknown> = {
|
||||
feature: task.title,
|
||||
description: task.description || '',
|
||||
created_at: task.createdAt.toISOString(),
|
||||
@@ -256,6 +413,11 @@ export async function createPlanIfNotExists(
|
||||
phases: []
|
||||
};
|
||||
|
||||
// Include xstateState for accurate restoration on reload
|
||||
if (xstateState) {
|
||||
plan.xstateState = xstateState;
|
||||
}
|
||||
|
||||
// Ensure directory exists - use try/catch pattern
|
||||
const planDir = path.dirname(planPath);
|
||||
try {
|
||||
|
||||
@@ -23,6 +23,7 @@ import { getIsolatedGitEnv, detectWorktreeBranch, refreshGitIndex } from '../../
|
||||
import { cleanupWorktree } from '../../utils/worktree-cleanup';
|
||||
import { killProcessGracefully } from '../../platform';
|
||||
import { stripAnsiCodes } from '../../../shared/utils/ansi-sanitizer';
|
||||
import { taskStateManager } from '../../task-state-manager';
|
||||
|
||||
// Regex pattern for validating git branch names
|
||||
export const GIT_BRANCH_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._/-]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$/;
|
||||
@@ -2332,6 +2333,7 @@ export function registerWorktreeHandlers(
|
||||
}
|
||||
|
||||
debug('Merge result. isStageOnly:', isStageOnly, 'newStatus:', newStatus, 'staged:', staged);
|
||||
const reviewReason = newStatus === 'human_review' ? 'completed' : undefined;
|
||||
|
||||
// Read suggested commit message if staging succeeded
|
||||
// OPTIMIZATION: Use async I/O to prevent blocking
|
||||
@@ -2379,6 +2381,7 @@ export function registerWorktreeHandlers(
|
||||
const plan = JSON.parse(planContent);
|
||||
plan.status = newStatus;
|
||||
plan.planStatus = planStatus;
|
||||
plan.reviewReason = reviewReason;
|
||||
plan.updated_at = new Date().toISOString();
|
||||
if (staged) {
|
||||
plan.stagedAt = new Date().toISOString();
|
||||
@@ -2437,10 +2440,8 @@ export function registerWorktreeHandlers(
|
||||
// Non-fatal: UI will still update, but status may not persist across refresh
|
||||
}
|
||||
|
||||
const mainWindow = getMainWindow();
|
||||
if (mainWindow) {
|
||||
mainWindow.webContents.send(IPC_CHANNELS.TASK_STATUS_CHANGE, taskId, newStatus);
|
||||
}
|
||||
// Route status change through TaskStateManager (XState) to avoid dual emission
|
||||
taskStateManager.handleManualStatusChange(taskId, newStatus as any, task, project);
|
||||
|
||||
resolve({
|
||||
success: true,
|
||||
@@ -2777,10 +2778,8 @@ export function registerWorktreeHandlers(
|
||||
// Only send status change to backlog if not skipped
|
||||
// (skip when caller will set a different status, e.g., 'done')
|
||||
if (!skipStatusChange) {
|
||||
const mainWindow = getMainWindow();
|
||||
if (mainWindow) {
|
||||
mainWindow.webContents.send(IPC_CHANNELS.TASK_STATUS_CHANGE, taskId, 'backlog');
|
||||
}
|
||||
// Route through TaskStateManager (XState) to avoid dual emission
|
||||
taskStateManager.handleManualStatusChange(taskId, 'backlog', task, project);
|
||||
}
|
||||
|
||||
return {
|
||||
|
||||
@@ -2,7 +2,7 @@ import { app } from 'electron';
|
||||
import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, Dirent } from 'fs';
|
||||
import path from 'path';
|
||||
import { v4 as uuidv4 } from 'uuid';
|
||||
import type { Project, ProjectSettings, Task, TaskStatus, TaskMetadata, ImplementationPlan, ReviewReason, PlanSubtask, KanbanPreferences } from '../shared/types';
|
||||
import type { Project, ProjectSettings, Task, TaskStatus, TaskMetadata, ImplementationPlan, ReviewReason, PlanSubtask, KanbanPreferences, ExecutionPhase } from '../shared/types';
|
||||
import { DEFAULT_PROJECT_SETTINGS, AUTO_BUILD_PATHS, getSpecsDir, JSON_ERROR_PREFIX, JSON_ERROR_TITLE_SUFFIX } from '../shared/constants';
|
||||
import { getAutoBuildPath, isInitialized } from './project-initializer';
|
||||
import { getTaskWorktreeDir } from './worktree-paths';
|
||||
@@ -461,7 +461,7 @@ export class ProjectStore {
|
||||
// Tasks with JSON errors go to human_review with errors reason
|
||||
const { status: finalStatus, reviewReason: finalReviewReason } = hasJsonError
|
||||
? { status: 'human_review' as TaskStatus, reviewReason: 'errors' as ReviewReason }
|
||||
: this.determineTaskStatusAndReason(plan, specPath, metadata);
|
||||
: this.determineTaskStatusAndReason(plan);
|
||||
|
||||
// Extract subtasks from plan (handle both 'subtasks' and 'chunks' naming)
|
||||
const subtasks = plan?.phases?.flatMap((phase) => {
|
||||
@@ -500,6 +500,16 @@ export class ProjectStore {
|
||||
}
|
||||
}
|
||||
|
||||
// Use persisted executionPhase (from text parser) or xstateState for exact restoration
|
||||
// Priority: executionPhase > xstateState > inferred from status
|
||||
const persistedPhase = (plan as { executionPhase?: string } | null)?.executionPhase as ExecutionPhase | undefined;
|
||||
const xstateState = (plan as { xstateState?: string } | null)?.xstateState;
|
||||
const executionProgress = persistedPhase
|
||||
? { phase: persistedPhase, phaseProgress: 50, overallProgress: 50 }
|
||||
: xstateState
|
||||
? this.inferExecutionProgressFromXState(xstateState)
|
||||
: this.inferExecutionProgress(plan?.status);
|
||||
|
||||
tasks.push({
|
||||
id: dir.name, // Use spec directory name as ID
|
||||
specId: dir.name,
|
||||
@@ -511,6 +521,7 @@ export class ProjectStore {
|
||||
logs: [],
|
||||
metadata,
|
||||
...(finalReviewReason !== undefined && { reviewReason: finalReviewReason }),
|
||||
...(executionProgress && { executionProgress }),
|
||||
stagedInMainProject,
|
||||
stagedAt,
|
||||
location, // Add location metadata (main vs worktree)
|
||||
@@ -528,30 +539,19 @@ export class ProjectStore {
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine task status and review reason based on plan and files.
|
||||
* Determine task status and review reason from the plan file.
|
||||
*
|
||||
* PRIORITY ORDER (to prevent status flip-flop during execution):
|
||||
* 1. Terminal statuses (done, pr_created, error) - ALWAYS respected
|
||||
* 2. Active process statuses (planning, coding, in_progress) - respected during execution
|
||||
* 3. Explicit human_review with reviewReason - respected to prevent recalculation
|
||||
* 4. QA report file status
|
||||
* 5. Calculated status from subtask analysis (fallback only)
|
||||
*
|
||||
* Review reasons:
|
||||
* - 'completed': All subtasks done, QA passed - ready for merge
|
||||
* - 'errors': Subtasks failed during execution - needs attention
|
||||
* - 'qa_rejected': QA found issues that need fixing
|
||||
* - 'plan_review': Spec creation complete, awaiting user approval
|
||||
* With the XState refactor, status and reviewReason are authoritative fields
|
||||
* written by the TaskStateManager. The renderer should not recompute status
|
||||
* from subtasks or QA files.
|
||||
*/
|
||||
private determineTaskStatusAndReason(
|
||||
plan: ImplementationPlan | null,
|
||||
specPath: string,
|
||||
metadata?: TaskMetadata
|
||||
plan: ImplementationPlan | null
|
||||
): { status: TaskStatus; reviewReason?: ReviewReason } {
|
||||
// Handle both 'subtasks' and 'chunks' naming conventions, filter out undefined
|
||||
const allSubtasks = plan?.phases?.flatMap((p) => p.subtasks || (p as { chunks?: PlanSubtask[] }).chunks || []).filter(Boolean) || [];
|
||||
if (!plan?.status) {
|
||||
return { status: 'backlog' };
|
||||
}
|
||||
|
||||
// Status mapping from plan.status values to TaskStatus
|
||||
const statusMap: Record<string, TaskStatus> = {
|
||||
'pending': 'backlog',
|
||||
'planning': 'in_progress',
|
||||
@@ -564,120 +564,82 @@ export class ProjectStore {
|
||||
'ai_review': 'ai_review',
|
||||
'pr_created': 'pr_created',
|
||||
'backlog': 'backlog',
|
||||
'error': 'error'
|
||||
'error': 'error',
|
||||
'queue': 'queue',
|
||||
'queued': 'queue'
|
||||
};
|
||||
|
||||
// Terminal statuses that should NEVER be overridden by calculation
|
||||
const TERMINAL_STATUSES = new Set<TaskStatus>(['done', 'pr_created', 'error']);
|
||||
const storedStatus = statusMap[plan.status] || 'backlog';
|
||||
const reviewReason = storedStatus === 'human_review' ? plan.reviewReason : undefined;
|
||||
|
||||
// ========================================================================
|
||||
// STEP 1: Check for terminal statuses (highest priority - always respected)
|
||||
// ========================================================================
|
||||
if (plan?.status) {
|
||||
const storedStatus = statusMap[plan.status];
|
||||
if (storedStatus && TERMINAL_STATUSES.has(storedStatus)) {
|
||||
return { status: storedStatus };
|
||||
}
|
||||
}
|
||||
return { status: storedStatus, reviewReason };
|
||||
}
|
||||
|
||||
// ========================================================================
|
||||
// STEP 2: Check for active process statuses during execution
|
||||
// These prevent status flip-flop while backend is actively running
|
||||
// ========================================================================
|
||||
if (plan?.status) {
|
||||
const storedStatus = statusMap[plan.status];
|
||||
const rawStatus = plan.status as string;
|
||||
const isActiveProcessStatus = rawStatus === 'planning' || rawStatus === 'coding' || rawStatus === 'in_progress';
|
||||
/**
|
||||
* Infer execution progress from plan status for XState snapshot restoration.
|
||||
* Maps plan status values to ExecutionPhase so buildSnapshotFromTask can
|
||||
* correctly determine the XState state (planning vs coding vs qa_review, etc.).
|
||||
*/
|
||||
private inferExecutionProgress(planStatus: string | undefined): { phase: ExecutionPhase; phaseProgress: number; overallProgress: number } | undefined {
|
||||
if (!planStatus) return undefined;
|
||||
|
||||
// Check if this is a plan review stage (spec creation complete, awaiting approval)
|
||||
const isPlanReviewStage = (plan as unknown as { planStatus?: string })?.planStatus === 'review';
|
||||
// Map plan status to execution phase
|
||||
const phaseMap: Record<string, ExecutionPhase> = {
|
||||
'pending': 'idle',
|
||||
'backlog': 'idle',
|
||||
'queue': 'idle',
|
||||
'queued': 'idle',
|
||||
'planning': 'planning',
|
||||
'coding': 'coding',
|
||||
'in_progress': 'coding', // Default in_progress to coding
|
||||
'review': 'qa_review',
|
||||
'ai_review': 'qa_review',
|
||||
'qa_review': 'qa_review',
|
||||
'qa_fixing': 'qa_fixing',
|
||||
'human_review': 'complete',
|
||||
'completed': 'complete',
|
||||
'done': 'complete',
|
||||
'error': 'failed'
|
||||
};
|
||||
|
||||
// During active execution, respect the stored status to prevent jumping
|
||||
if (isActiveProcessStatus && storedStatus === 'in_progress') {
|
||||
return { status: 'in_progress' };
|
||||
}
|
||||
const phase = phaseMap[planStatus];
|
||||
if (!phase) return undefined;
|
||||
|
||||
// Plan review stage (human approval of spec before coding starts)
|
||||
if (isPlanReviewStage && storedStatus === 'human_review') {
|
||||
return { status: 'human_review', reviewReason: 'plan_review' };
|
||||
}
|
||||
return {
|
||||
phase,
|
||||
phaseProgress: 50,
|
||||
overallProgress: 50
|
||||
};
|
||||
}
|
||||
|
||||
// Explicit human_review status should be preserved unless we have evidence to change it
|
||||
if (storedStatus === 'human_review') {
|
||||
// Infer review reason from subtask/QA state
|
||||
const hasFailedSubtasks = allSubtasks.some((s) => s.status === 'failed');
|
||||
const allCompleted = allSubtasks.length > 0 && allSubtasks.every((s) => s.status === 'completed');
|
||||
let reviewReason: ReviewReason | undefined;
|
||||
if (hasFailedSubtasks) {
|
||||
reviewReason = 'errors';
|
||||
} else if (allCompleted) {
|
||||
reviewReason = 'completed';
|
||||
}
|
||||
return { status: 'human_review', reviewReason };
|
||||
}
|
||||
/**
|
||||
* Infer execution progress from persisted XState state.
|
||||
* This is more precise than inferring from plan status since it uses the exact machine state.
|
||||
*/
|
||||
private inferExecutionProgressFromXState(xstateState: string): { phase: ExecutionPhase; phaseProgress: number; overallProgress: number } | undefined {
|
||||
// Map XState state directly to execution phase
|
||||
const phaseMap: Record<string, ExecutionPhase> = {
|
||||
'backlog': 'idle',
|
||||
'planning': 'planning',
|
||||
'plan_review': 'planning',
|
||||
'coding': 'coding',
|
||||
'qa_review': 'qa_review',
|
||||
'qa_fixing': 'qa_fixing',
|
||||
'human_review': 'complete',
|
||||
'error': 'failed',
|
||||
'creating_pr': 'complete',
|
||||
'pr_created': 'complete',
|
||||
'done': 'complete'
|
||||
};
|
||||
|
||||
// Explicit ai_review status should be preserved
|
||||
if (storedStatus === 'ai_review') {
|
||||
return { status: 'ai_review' };
|
||||
}
|
||||
}
|
||||
const phase = phaseMap[xstateState];
|
||||
if (!phase) return undefined;
|
||||
|
||||
// ========================================================================
|
||||
// STEP 3: Check QA report file for status info
|
||||
// ========================================================================
|
||||
const qaReportPath = path.join(specPath, AUTO_BUILD_PATHS.QA_REPORT);
|
||||
if (existsSync(qaReportPath)) {
|
||||
try {
|
||||
const content = readFileSync(qaReportPath, 'utf-8');
|
||||
if (content.includes('REJECTED') || content.includes('FAILED')) {
|
||||
return { status: 'human_review', reviewReason: 'qa_rejected' };
|
||||
}
|
||||
if (content.includes('PASSED') || content.includes('APPROVED')) {
|
||||
// QA passed - if all subtasks done, move to human_review
|
||||
if (allSubtasks.length > 0 && allSubtasks.every((s) => s.status === 'completed')) {
|
||||
return { status: 'human_review', reviewReason: 'completed' };
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Ignore read errors
|
||||
}
|
||||
}
|
||||
|
||||
// ========================================================================
|
||||
// STEP 4: Calculate status from subtask analysis (fallback only)
|
||||
// This is the lowest priority - only used when no explicit status is set
|
||||
// ========================================================================
|
||||
let calculatedStatus: TaskStatus = 'backlog';
|
||||
let reviewReason: ReviewReason | undefined;
|
||||
|
||||
if (allSubtasks.length > 0) {
|
||||
const completed = allSubtasks.filter((s) => s.status === 'completed').length;
|
||||
const inProgress = allSubtasks.filter((s) => s.status === 'in_progress').length;
|
||||
const failed = allSubtasks.filter((s) => s.status === 'failed').length;
|
||||
|
||||
if (completed === allSubtasks.length) {
|
||||
// All subtasks completed - check QA status
|
||||
const qaSignoff = (plan as unknown as Record<string, unknown>)?.qa_signoff as { status?: string } | undefined;
|
||||
if (qaSignoff?.status === 'approved') {
|
||||
calculatedStatus = 'human_review';
|
||||
reviewReason = 'completed';
|
||||
} else {
|
||||
// Manual tasks skip AI review and go directly to human review
|
||||
calculatedStatus = metadata?.sourceType === 'manual' ? 'human_review' : 'ai_review';
|
||||
if (metadata?.sourceType === 'manual') {
|
||||
reviewReason = 'completed';
|
||||
}
|
||||
}
|
||||
} else if (failed > 0) {
|
||||
// Some subtasks failed - needs human attention
|
||||
calculatedStatus = 'human_review';
|
||||
reviewReason = 'errors';
|
||||
} else if (inProgress > 0 || completed > 0) {
|
||||
calculatedStatus = 'in_progress';
|
||||
}
|
||||
}
|
||||
|
||||
return { status: calculatedStatus, reviewReason: calculatedStatus === 'human_review' ? reviewReason : undefined };
|
||||
return {
|
||||
phase,
|
||||
phaseProgress: phase === 'complete' ? 100 : 50,
|
||||
overallProgress: phase === 'complete' ? 100 : 50
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,473 @@
|
||||
import { createActor } from 'xstate';
|
||||
import type { ActorRefFrom } from 'xstate';
|
||||
import type { BrowserWindow } from 'electron';
|
||||
import type { TaskEventPayload } from './agent/task-event-schema';
|
||||
import type { Project, Task, TaskStatus, ReviewReason, ExecutionPhase } from '../shared/types';
|
||||
import { taskMachine, type TaskEvent } from '../shared/state-machines';
|
||||
import { IPC_CHANNELS } from '../shared/constants';
|
||||
import { safeSendToRenderer } from './ipc-handlers/utils';
|
||||
import { getPlanPath, persistPlanStatusAndReasonSync } from './ipc-handlers/task/plan-file-utils';
|
||||
import { findTaskWorktree } from './worktree-paths';
|
||||
import { getSpecsDir, AUTO_BUILD_PATHS } from '../shared/constants';
|
||||
import { existsSync } from 'fs';
|
||||
import path from 'path';
|
||||
|
||||
type TaskActor = ActorRefFrom<typeof taskMachine>;
|
||||
|
||||
/** Maps XState states to execution phases. Shared by mapStateToExecutionPhase and emitPhaseFromState. */
|
||||
const XSTATE_TO_PHASE: Record<string, ExecutionPhase> = {
|
||||
'backlog': 'idle',
|
||||
'planning': 'planning',
|
||||
'plan_review': 'planning',
|
||||
'coding': 'coding',
|
||||
'qa_review': 'qa_review',
|
||||
'qa_fixing': 'qa_fixing',
|
||||
'human_review': 'complete',
|
||||
'error': 'failed',
|
||||
'creating_pr': 'complete',
|
||||
'pr_created': 'complete',
|
||||
'done': 'complete'
|
||||
};
|
||||
|
||||
interface TaskContextEntry {
|
||||
task: Task;
|
||||
project: Project;
|
||||
}
|
||||
|
||||
const TERMINAL_EVENTS = new Set<string>([
|
||||
'QA_PASSED',
|
||||
'PLANNING_FAILED',
|
||||
'CODING_FAILED',
|
||||
'QA_MAX_ITERATIONS',
|
||||
'QA_AGENT_ERROR',
|
||||
'ALL_SUBTASKS_DONE'
|
||||
]);
|
||||
|
||||
export class TaskStateManager {
|
||||
private actors = new Map<string, TaskActor>();
|
||||
private lastSequenceByTask = new Map<string, number>();
|
||||
private lastStateByTask = new Map<string, string>();
|
||||
private taskContextById = new Map<string, TaskContextEntry>();
|
||||
private terminalEventSeen = new Set<string>();
|
||||
private getMainWindow: (() => BrowserWindow | null) | null = null;
|
||||
|
||||
configure(getMainWindow: () => BrowserWindow | null): void {
|
||||
this.getMainWindow = getMainWindow;
|
||||
}
|
||||
|
||||
handleTaskEvent(taskId: string, event: TaskEventPayload, task: Task, project: Project): boolean {
|
||||
const lastSeq = this.lastSequenceByTask.get(taskId);
|
||||
console.log(`[TaskStateManager] handleTaskEvent: ${event.type} seq=${event.sequence}, lastSeq=${lastSeq}`);
|
||||
|
||||
if (!this.isNewSequence(taskId, event.sequence)) {
|
||||
console.log(`[TaskStateManager] Event ${event.type} DROPPED - sequence ${event.sequence} not newer than ${lastSeq}`);
|
||||
return false;
|
||||
}
|
||||
this.setTaskContext(taskId, task, project);
|
||||
this.lastSequenceByTask.set(taskId, event.sequence);
|
||||
|
||||
if (TERMINAL_EVENTS.has(event.type)) {
|
||||
this.terminalEventSeen.add(taskId);
|
||||
}
|
||||
|
||||
const actor = this.getOrCreateActor(taskId);
|
||||
const stateBefore = String(actor.getSnapshot().value);
|
||||
console.log(`[TaskStateManager] Sending ${event.type} to actor in state: ${stateBefore}`);
|
||||
actor.send(event as TaskEvent);
|
||||
const stateAfter = String(actor.getSnapshot().value);
|
||||
console.log(`[TaskStateManager] After ${event.type}: state ${stateBefore} -> ${stateAfter}`);
|
||||
return true;
|
||||
}
|
||||
|
||||
handleProcessExited(
|
||||
taskId: string,
|
||||
exitCode: number | null,
|
||||
task?: Task,
|
||||
project?: Project
|
||||
): void {
|
||||
if (task && project) {
|
||||
this.setTaskContext(taskId, task, project);
|
||||
}
|
||||
if (this.terminalEventSeen.has(taskId)) {
|
||||
return;
|
||||
}
|
||||
const actor = this.getOrCreateActor(taskId);
|
||||
actor.send({
|
||||
type: 'PROCESS_EXITED',
|
||||
exitCode: exitCode ?? -1,
|
||||
unexpected: true
|
||||
} satisfies TaskEvent);
|
||||
}
|
||||
|
||||
handleUiEvent(taskId: string, event: TaskEvent, task: Task, project: Project): void {
|
||||
console.log(`[TaskStateManager] handleUiEvent: ${event.type} for task ${taskId}`);
|
||||
this.setTaskContext(taskId, task, project);
|
||||
const actor = this.getOrCreateActor(taskId);
|
||||
const stateBefore = String(actor.getSnapshot().value);
|
||||
console.log(`[TaskStateManager] Sending UI event ${event.type} to actor in state: ${stateBefore}`);
|
||||
actor.send(event);
|
||||
const stateAfter = String(actor.getSnapshot().value);
|
||||
console.log(`[TaskStateManager] After UI event ${event.type}: state ${stateBefore} -> ${stateAfter}`);
|
||||
}
|
||||
|
||||
handleManualStatusChange(taskId: string, status: TaskStatus, task: Task, project: Project): boolean {
|
||||
switch (status) {
|
||||
case 'done':
|
||||
this.handleUiEvent(taskId, { type: 'MARK_DONE' }, task, project);
|
||||
return true;
|
||||
case 'pr_created':
|
||||
this.handleUiEvent(
|
||||
taskId,
|
||||
{ type: 'PR_CREATED', prUrl: task.metadata?.prUrl ?? '' },
|
||||
task,
|
||||
project
|
||||
);
|
||||
return true;
|
||||
case 'in_progress': {
|
||||
// Use XState as source of truth for determining correct event
|
||||
const currentState = this.getCurrentState(taskId);
|
||||
if (currentState === 'plan_review') {
|
||||
this.handleUiEvent(taskId, { type: 'PLAN_APPROVED' }, task, project);
|
||||
} else if (currentState === 'human_review' || currentState === 'error') {
|
||||
this.handleUiEvent(taskId, { type: 'USER_RESUMED' }, task, project);
|
||||
} else if (!currentState && task.reviewReason === 'plan_review') {
|
||||
// Fallback: No actor exists (e.g., after app restart), use task data
|
||||
this.handleUiEvent(taskId, { type: 'PLAN_APPROVED' }, task, project);
|
||||
} else {
|
||||
this.handleUiEvent(taskId, { type: 'USER_RESUMED' }, task, project);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
case 'backlog':
|
||||
this.handleUiEvent(taskId, { type: 'USER_STOPPED', hasPlan: false }, task, project);
|
||||
return true;
|
||||
case 'human_review':
|
||||
// Already in human_review (e.g., stage-only merge keeps task in review).
|
||||
// Emit status directly since there's no XState transition needed.
|
||||
this.emitStatus(taskId, 'human_review', task.reviewReason ?? 'completed', project.id);
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
setLastSequence(taskId: string, sequence: number): void {
|
||||
this.lastSequenceByTask.set(taskId, sequence);
|
||||
}
|
||||
|
||||
getLastSequence(taskId: string): number | undefined {
|
||||
return this.lastSequenceByTask.get(taskId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current XState state for a task.
|
||||
* Returns undefined if no actor exists for the task.
|
||||
*/
|
||||
getCurrentState(taskId: string): string | undefined {
|
||||
const actor = this.actors.get(taskId);
|
||||
if (!actor) {
|
||||
return undefined;
|
||||
}
|
||||
return String(actor.getSnapshot().value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the task is currently in plan_review state.
|
||||
* Used by TASK_START to determine correct event to send.
|
||||
*/
|
||||
isInPlanReview(taskId: string): boolean {
|
||||
return this.getCurrentState(taskId) === 'plan_review';
|
||||
}
|
||||
|
||||
clearTask(taskId: string): void {
|
||||
this.lastSequenceByTask.delete(taskId);
|
||||
this.lastStateByTask.delete(taskId);
|
||||
this.terminalEventSeen.delete(taskId);
|
||||
this.taskContextById.delete(taskId);
|
||||
const actor = this.actors.get(taskId);
|
||||
if (actor) {
|
||||
actor.stop();
|
||||
this.actors.delete(taskId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear all task state. Called by TASK_LIST handler when forceRefresh is true.
|
||||
* This ensures actors are recreated with fresh task data when the user
|
||||
* triggers a manual refresh from the UI.
|
||||
*
|
||||
* Note: lastSequenceByTask is preserved to prevent duplicate event processing
|
||||
* if backend events arrive during the refresh window. Sequence numbers are
|
||||
* specific to task execution sessions and should remain valid across UI refreshes.
|
||||
*/
|
||||
clearAllTasks(): void {
|
||||
for (const [_taskId, actor] of this.actors) {
|
||||
actor.stop();
|
||||
}
|
||||
this.actors.clear();
|
||||
// Preserve lastSequenceByTask to prevent duplicate event processing during refresh
|
||||
// Only clear state that needs to be rebuilt from fresh task data
|
||||
this.lastStateByTask.clear();
|
||||
this.terminalEventSeen.clear();
|
||||
this.taskContextById.clear();
|
||||
console.log('[TaskStateManager] Cleared task actors and state for refresh (preserved sequence tracking)');
|
||||
}
|
||||
|
||||
private setTaskContext(taskId: string, task: Task, project: Project): void {
|
||||
this.taskContextById.set(taskId, { task, project });
|
||||
}
|
||||
|
||||
private getOrCreateActor(taskId: string): TaskActor {
|
||||
const existing = this.actors.get(taskId);
|
||||
if (existing) {
|
||||
console.log(`[TaskStateManager] Using existing actor for ${taskId}, current state:`, String(existing.getSnapshot().value));
|
||||
return existing;
|
||||
}
|
||||
|
||||
const contextEntry = this.taskContextById.get(taskId);
|
||||
const snapshot = contextEntry
|
||||
? this.buildSnapshotFromTask(contextEntry.task)
|
||||
: undefined;
|
||||
|
||||
if (contextEntry) {
|
||||
console.log(`[TaskStateManager] Creating new actor for ${taskId} from task:`, {
|
||||
status: contextEntry.task.status,
|
||||
reviewReason: contextEntry.task.reviewReason,
|
||||
phase: contextEntry.task.executionProgress?.phase,
|
||||
initialState: snapshot ? String(snapshot.value) : 'default (backlog)'
|
||||
});
|
||||
} else {
|
||||
console.log(`[TaskStateManager] Creating new actor for ${taskId} with default state (no context entry)`);
|
||||
}
|
||||
|
||||
const actor = snapshot
|
||||
? createActor(taskMachine, { snapshot })
|
||||
: createActor(taskMachine);
|
||||
actor.subscribe((snapshot) => {
|
||||
const stateValue = String(snapshot.value);
|
||||
const lastState = this.lastStateByTask.get(taskId);
|
||||
|
||||
// Debug: Log all state transitions
|
||||
console.log(`[TaskStateManager] XState transition for ${taskId}:`, {
|
||||
from: lastState,
|
||||
to: stateValue,
|
||||
contextReviewReason: snapshot.context.reviewReason
|
||||
});
|
||||
|
||||
if (lastState === stateValue) {
|
||||
return;
|
||||
}
|
||||
this.lastStateByTask.set(taskId, stateValue);
|
||||
|
||||
const contextEntry = this.taskContextById.get(taskId);
|
||||
if (!contextEntry) {
|
||||
console.debug(`[TaskStateManager] No context for task ${taskId} during state transition to ${stateValue} - skipping emit (may occur after clearTask during event processing)`);
|
||||
return;
|
||||
}
|
||||
const { task, project } = contextEntry;
|
||||
const { status, reviewReason } = mapStateToLegacy(
|
||||
stateValue,
|
||||
snapshot.context.reviewReason
|
||||
);
|
||||
|
||||
// Map XState state to execution phase for persistence
|
||||
const executionPhase = this.mapStateToExecutionPhase(stateValue);
|
||||
|
||||
// Debug: Log the mapped status and reviewReason
|
||||
console.log(`[TaskStateManager] Emitting status for ${taskId}:`, {
|
||||
status,
|
||||
reviewReason,
|
||||
xstateState: stateValue,
|
||||
executionPhase,
|
||||
projectId: project.id
|
||||
});
|
||||
|
||||
this.persistStatus(task, project, status, reviewReason, stateValue, executionPhase);
|
||||
this.emitStatus(taskId, status, reviewReason, project.id);
|
||||
|
||||
// Also emit execution progress to sync phase display with column
|
||||
// This ensures crisp transitions - phase and column update together
|
||||
this.emitPhaseFromState(taskId, stateValue, project.id);
|
||||
});
|
||||
|
||||
actor.start();
|
||||
this.actors.set(taskId, actor);
|
||||
return actor;
|
||||
}
|
||||
|
||||
private persistStatus(
|
||||
task: Task,
|
||||
project: Project,
|
||||
status: TaskStatus,
|
||||
reviewReason?: ReviewReason,
|
||||
xstateState?: string,
|
||||
executionPhase?: string
|
||||
): void {
|
||||
const mainPlanPath = getPlanPath(project, task);
|
||||
persistPlanStatusAndReasonSync(mainPlanPath, status, reviewReason, project.id, xstateState, executionPhase);
|
||||
|
||||
const worktreePath = findTaskWorktree(project.path, task.specId);
|
||||
if (!worktreePath) return;
|
||||
|
||||
const specsBaseDir = getSpecsDir(project.autoBuildPath);
|
||||
const worktreePlanPath = path.join(
|
||||
worktreePath,
|
||||
specsBaseDir,
|
||||
task.specId,
|
||||
AUTO_BUILD_PATHS.IMPLEMENTATION_PLAN
|
||||
);
|
||||
if (existsSync(worktreePlanPath)) {
|
||||
persistPlanStatusAndReasonSync(worktreePlanPath, status, reviewReason, project.id, xstateState, executionPhase);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Map XState state to execution phase string
|
||||
*/
|
||||
private mapStateToExecutionPhase(xstateState: string): ExecutionPhase {
|
||||
return XSTATE_TO_PHASE[xstateState] || 'idle';
|
||||
}
|
||||
|
||||
private emitStatus(
|
||||
taskId: string,
|
||||
status: TaskStatus,
|
||||
reviewReason: ReviewReason | undefined,
|
||||
projectId?: string
|
||||
): void {
|
||||
if (!this.getMainWindow) {
|
||||
console.warn(`[TaskStateManager] emitStatus: No main window, cannot emit status ${status} for ${taskId}`);
|
||||
return;
|
||||
}
|
||||
console.log(`[TaskStateManager] emitStatus: Sending TASK_STATUS_CHANGE for ${taskId}:`, { status, reviewReason, projectId });
|
||||
safeSendToRenderer(
|
||||
this.getMainWindow,
|
||||
IPC_CHANNELS.TASK_STATUS_CHANGE,
|
||||
taskId,
|
||||
status,
|
||||
projectId,
|
||||
reviewReason
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit execution progress to sync phase display with XState state.
|
||||
* This ensures the card shows the correct phase when XState transitions.
|
||||
*/
|
||||
private emitPhaseFromState(
|
||||
taskId: string,
|
||||
xstateState: string,
|
||||
projectId?: string
|
||||
): void {
|
||||
if (!this.getMainWindow) return;
|
||||
|
||||
const phase = XSTATE_TO_PHASE[xstateState] || 'idle';
|
||||
|
||||
// Emit execution progress with the phase derived from XState
|
||||
safeSendToRenderer(
|
||||
this.getMainWindow,
|
||||
IPC_CHANNELS.TASK_EXECUTION_PROGRESS,
|
||||
taskId,
|
||||
{
|
||||
phase,
|
||||
phaseProgress: phase === 'complete' ? 100 : 50,
|
||||
overallProgress: phase === 'complete' ? 100 : 50,
|
||||
message: `State: ${xstateState}`,
|
||||
sequenceNumber: Date.now() // Use timestamp as sequence to ensure it's newer
|
||||
},
|
||||
projectId
|
||||
);
|
||||
}
|
||||
|
||||
private isNewSequence(taskId: string, sequence: number): boolean {
|
||||
const last = this.lastSequenceByTask.get(taskId);
|
||||
// Use >= to accept the first event when sequence equals last (e.g., both are 0)
|
||||
// This handles the case where we reload lastSequence from plan file and the next
|
||||
// event has the same sequence number (which shouldn't happen, but we should be lenient)
|
||||
return last === undefined || sequence >= last;
|
||||
}
|
||||
|
||||
private buildSnapshotFromTask(task: Task) {
|
||||
const status = task.status;
|
||||
const reviewReason = task.reviewReason;
|
||||
const executionPhase = task.executionProgress?.phase;
|
||||
let stateValue: string = 'backlog';
|
||||
let contextReviewReason: ReviewReason | undefined;
|
||||
|
||||
switch (status) {
|
||||
case 'in_progress':
|
||||
// Use executionProgress.phase to determine if we're in planning or coding
|
||||
// This is important because both phases have status 'in_progress'
|
||||
if (executionPhase === 'planning') {
|
||||
stateValue = 'planning';
|
||||
} else if (executionPhase === 'qa_review') {
|
||||
stateValue = 'qa_review';
|
||||
} else if (executionPhase === 'qa_fixing') {
|
||||
stateValue = 'qa_fixing';
|
||||
} else {
|
||||
// Default to coding for 'coding', 'complete', or unknown phases
|
||||
stateValue = 'coding';
|
||||
}
|
||||
break;
|
||||
case 'ai_review':
|
||||
stateValue = 'qa_review';
|
||||
break;
|
||||
case 'human_review':
|
||||
stateValue = reviewReason === 'plan_review' ? 'plan_review' : 'human_review';
|
||||
contextReviewReason = reviewReason;
|
||||
break;
|
||||
case 'pr_created':
|
||||
stateValue = 'pr_created';
|
||||
break;
|
||||
case 'done':
|
||||
stateValue = 'done';
|
||||
break;
|
||||
case 'error':
|
||||
stateValue = 'error';
|
||||
contextReviewReason = reviewReason ?? 'errors';
|
||||
break;
|
||||
case 'backlog':
|
||||
default:
|
||||
stateValue = 'backlog';
|
||||
break;
|
||||
}
|
||||
|
||||
return taskMachine.resolveState({
|
||||
value: stateValue,
|
||||
context: {
|
||||
reviewReason: contextReviewReason
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export const taskStateManager = new TaskStateManager();
|
||||
|
||||
function mapStateToLegacy(
|
||||
state: string,
|
||||
reviewReason?: ReviewReason
|
||||
): { status: TaskStatus; reviewReason?: ReviewReason } {
|
||||
switch (state) {
|
||||
case 'backlog':
|
||||
return { status: 'backlog' };
|
||||
case 'planning':
|
||||
case 'coding':
|
||||
return { status: 'in_progress' };
|
||||
case 'plan_review':
|
||||
return { status: 'human_review', reviewReason: 'plan_review' };
|
||||
case 'qa_review':
|
||||
case 'qa_fixing':
|
||||
return { status: 'ai_review' };
|
||||
case 'human_review':
|
||||
return { status: 'human_review', reviewReason };
|
||||
case 'error':
|
||||
return { status: 'human_review', reviewReason: 'errors' };
|
||||
case 'creating_pr':
|
||||
return { status: 'human_review', reviewReason: 'completed' };
|
||||
case 'pr_created':
|
||||
return { status: 'pr_created' };
|
||||
case 'done':
|
||||
return { status: 'done' };
|
||||
default:
|
||||
return { status: 'backlog' };
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ import type {
|
||||
TaskMetadata,
|
||||
TaskLogs,
|
||||
TaskLogStreamChunk,
|
||||
ReviewReason,
|
||||
MergeProgress,
|
||||
SupportedIDE,
|
||||
SupportedTerminal,
|
||||
@@ -75,7 +76,7 @@ export interface TaskAPI {
|
||||
onTaskProgress: (callback: (taskId: string, plan: ImplementationPlan, projectId?: string) => void) => () => void;
|
||||
onTaskError: (callback: (taskId: string, error: string, projectId?: string) => void) => () => void;
|
||||
onTaskLog: (callback: (taskId: string, log: string, projectId?: string) => void) => () => void;
|
||||
onTaskStatusChange: (callback: (taskId: string, status: TaskStatus, projectId?: string) => void) => () => void;
|
||||
onTaskStatusChange: (callback: (taskId: string, status: TaskStatus, projectId?: string, reviewReason?: ReviewReason) => void) => () => void;
|
||||
onTaskExecutionProgress: (
|
||||
callback: (taskId: string, progress: import('../../shared/types').ExecutionProgress, projectId?: string) => void
|
||||
) => () => void;
|
||||
@@ -243,15 +244,16 @@ export const createTaskAPI = (): TaskAPI => ({
|
||||
},
|
||||
|
||||
onTaskStatusChange: (
|
||||
callback: (taskId: string, status: TaskStatus, projectId?: string) => void
|
||||
callback: (taskId: string, status: TaskStatus, projectId?: string, reviewReason?: ReviewReason) => void
|
||||
): (() => void) => {
|
||||
const handler = (
|
||||
_event: Electron.IpcRendererEvent,
|
||||
taskId: string,
|
||||
status: TaskStatus,
|
||||
projectId?: string
|
||||
projectId?: string,
|
||||
reviewReason?: ReviewReason
|
||||
): void => {
|
||||
callback(taskId, status, projectId);
|
||||
callback(taskId, status, projectId, reviewReason);
|
||||
};
|
||||
ipcRenderer.on(IPC_CHANNELS.TASK_STATUS_CHANGE, handler);
|
||||
return () => {
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,4 +1,4 @@
|
||||
import { useState, useEffect, useRef, useCallback, memo, useMemo } from 'react';
|
||||
import { useState, useEffect, useRef, memo, useMemo } from 'react';
|
||||
import { useTranslation } from 'react-i18next';
|
||||
import { Play, Square, Clock, Zap, Target, Shield, Gauge, Palette, FileCode, Bug, Wrench, Loader2, AlertTriangle, RotateCcw, Archive, GitPullRequest, MoreVertical } from 'lucide-react';
|
||||
import { Card, CardContent } from './ui/card';
|
||||
@@ -31,7 +31,7 @@ import {
|
||||
JSON_ERROR_PREFIX,
|
||||
JSON_ERROR_TITLE_SUFFIX
|
||||
} from '../../shared/constants';
|
||||
import { startTask, stopTask, checkTaskRunning, recoverStuckTask, isIncompleteHumanReview, archiveTasks } from '../stores/task-store';
|
||||
import { startTask, stopTask, checkTaskRunning, recoverStuckTask, isIncompleteHumanReview, archiveTasks, hasRecentActivity } from '../stores/task-store';
|
||||
import type { Task, TaskCategory, ReviewReason, TaskStatus } from '../../shared/types';
|
||||
|
||||
// Category icon mapping
|
||||
@@ -47,13 +47,11 @@ const CategoryIcon: Record<TaskCategory, typeof Zap> = {
|
||||
testing: FileCode
|
||||
};
|
||||
|
||||
// Phases where stuck detection should be skipped (terminal states + initial planning)
|
||||
// Defined outside component to avoid recreation on every render
|
||||
const STUCK_CHECK_SKIP_PHASES = ['complete', 'failed', 'planning'] as const;
|
||||
|
||||
function shouldSkipStuckCheck(phase: string | undefined): boolean {
|
||||
return STUCK_CHECK_SKIP_PHASES.includes(phase as typeof STUCK_CHECK_SKIP_PHASES[number]);
|
||||
}
|
||||
// Catastrophic stuck detection interval (ms).
|
||||
// XState handles all normal process-exit transitions via PROCESS_EXITED events.
|
||||
// This is a last-resort safety net: if XState somehow fails to transition the task
|
||||
// out of in_progress after the process dies, flag it as stuck after 60 seconds.
|
||||
const STUCK_CHECK_INTERVAL_MS = 60_000;
|
||||
|
||||
interface TaskCardProps {
|
||||
task: Task;
|
||||
@@ -136,10 +134,7 @@ export const TaskCard = memo(function TaskCard({
|
||||
const { t } = useTranslation(['tasks', 'errors']);
|
||||
const [isStuck, setIsStuck] = useState(false);
|
||||
const [isRecovering, setIsRecovering] = useState(false);
|
||||
const stuckCheckRef = useRef<{ timeout: NodeJS.Timeout | null; interval: NodeJS.Timeout | null }>({
|
||||
timeout: null,
|
||||
interval: null
|
||||
});
|
||||
const stuckIntervalRef = useRef<NodeJS.Timeout | null>(null);
|
||||
|
||||
const isRunning = task.status === 'in_progress';
|
||||
const executionPhase = task.executionProgress?.phase;
|
||||
@@ -190,88 +185,43 @@ export const TaskCard = memo(function TaskCard({
|
||||
));
|
||||
}, [task.status, onStatusChange, t]);
|
||||
|
||||
// Memoized stuck check function to avoid recreating on every render
|
||||
const performStuckCheck = useCallback(() => {
|
||||
const currentPhase = task.executionProgress?.phase;
|
||||
if (shouldSkipStuckCheck(currentPhase)) {
|
||||
if (window.DEBUG) {
|
||||
console.log(`[TaskCard] Stuck check skipped for ${task.id} - phase is '${currentPhase}' (planning/terminal phases don't need process verification)`);
|
||||
}
|
||||
// Catastrophic stuck detection — last-resort safety net.
|
||||
// XState handles all normal transitions via PROCESS_EXITED events.
|
||||
// This only fires if XState somehow fails to transition after 60s with no activity.
|
||||
useEffect(() => {
|
||||
if (!isRunning) {
|
||||
setIsStuck(false);
|
||||
if (stuckIntervalRef.current) {
|
||||
clearInterval(stuckIntervalRef.current);
|
||||
stuckIntervalRef.current = null;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Use requestIdleCallback for non-blocking check when available
|
||||
const doCheck = () => {
|
||||
stuckIntervalRef.current = setInterval(() => {
|
||||
// If any activity (status, progress, logs) was recorded recently, task is alive
|
||||
if (hasRecentActivity(task.id)) {
|
||||
setIsStuck(false);
|
||||
return;
|
||||
}
|
||||
|
||||
// No activity for 60s — verify process is actually gone
|
||||
checkTaskRunning(task.id).then((actuallyRunning) => {
|
||||
// Double-check the phase again in case it changed while waiting
|
||||
const latestPhase = task.executionProgress?.phase;
|
||||
if (shouldSkipStuckCheck(latestPhase)) {
|
||||
// Re-check activity in case something arrived while the IPC was in flight
|
||||
if (hasRecentActivity(task.id)) {
|
||||
setIsStuck(false);
|
||||
} else {
|
||||
setIsStuck(!actuallyRunning);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
if ('requestIdleCallback' in window) {
|
||||
(window as Window & { requestIdleCallback: (cb: () => void) => void }).requestIdleCallback(doCheck);
|
||||
} else {
|
||||
doCheck();
|
||||
}
|
||||
}, [task.id, task.executionProgress?.phase]);
|
||||
|
||||
// Check if task is stuck (status says in_progress but no actual process)
|
||||
// Add a longer grace period to avoid false positives during process spawn
|
||||
useEffect(() => {
|
||||
if (!isRunning) {
|
||||
setIsStuck(false);
|
||||
// Clear any pending checks
|
||||
if (stuckCheckRef.current.timeout) {
|
||||
clearTimeout(stuckCheckRef.current.timeout);
|
||||
stuckCheckRef.current.timeout = null;
|
||||
}
|
||||
if (stuckCheckRef.current.interval) {
|
||||
clearInterval(stuckCheckRef.current.interval);
|
||||
stuckCheckRef.current.interval = null;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Initial check after 5s grace period (increased from 2s)
|
||||
stuckCheckRef.current.timeout = setTimeout(performStuckCheck, 5000);
|
||||
|
||||
// Periodic re-check every 30 seconds (reduced frequency from 15s)
|
||||
stuckCheckRef.current.interval = setInterval(performStuckCheck, 30000);
|
||||
}, STUCK_CHECK_INTERVAL_MS);
|
||||
|
||||
return () => {
|
||||
if (stuckCheckRef.current.timeout) {
|
||||
clearTimeout(stuckCheckRef.current.timeout);
|
||||
}
|
||||
if (stuckCheckRef.current.interval) {
|
||||
clearInterval(stuckCheckRef.current.interval);
|
||||
if (stuckIntervalRef.current) {
|
||||
clearInterval(stuckIntervalRef.current);
|
||||
}
|
||||
};
|
||||
}, [task.id, isRunning, performStuckCheck]);
|
||||
|
||||
// Add visibility change handler to re-validate on focus (debounced)
|
||||
useEffect(() => {
|
||||
let debounceTimeout: NodeJS.Timeout | null = null;
|
||||
|
||||
const handleVisibilityChange = () => {
|
||||
if (document.visibilityState === 'visible' && isRunning) {
|
||||
// Debounce visibility checks to avoid rapid re-checks
|
||||
if (debounceTimeout) clearTimeout(debounceTimeout);
|
||||
debounceTimeout = setTimeout(performStuckCheck, 500);
|
||||
}
|
||||
};
|
||||
|
||||
document.addEventListener('visibilitychange', handleVisibilityChange);
|
||||
return () => {
|
||||
document.removeEventListener('visibilitychange', handleVisibilityChange);
|
||||
if (debounceTimeout) clearTimeout(debounceTimeout);
|
||||
};
|
||||
}, [isRunning, performStuckCheck]);
|
||||
}, [task.id, isRunning]);
|
||||
|
||||
const handleStartStop = (e: React.MouseEvent) => {
|
||||
e.stopPropagation();
|
||||
@@ -349,12 +299,18 @@ export const TaskCard = memo(function TaskCard({
|
||||
return { label: t('reviewReason.qaIssues'), variant: 'warning' };
|
||||
case 'plan_review':
|
||||
return { label: t('reviewReason.approvePlan'), variant: 'warning' };
|
||||
case 'stopped':
|
||||
return { label: t('reviewReason.stopped'), variant: 'warning' };
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
const reviewReasonInfo = task.status === 'human_review' ? getReviewReasonLabel(task.reviewReason) : null;
|
||||
// When executionPhase is 'complete', always show 'completed' badge regardless of reviewReason
|
||||
// This ensures the user sees "Complete" when the task finished successfully
|
||||
const effectiveReviewReason: ReviewReason | undefined =
|
||||
executionPhase === 'complete' ? 'completed' : task.reviewReason;
|
||||
const reviewReasonInfo = task.status === 'human_review' ? getReviewReasonLabel(effectiveReviewReason) : null;
|
||||
|
||||
const isArchived = !!task.metadata?.archivedAt;
|
||||
|
||||
|
||||
@@ -393,7 +393,8 @@ function TaskDetailModalContent({ open, task, onOpenChange, onSwitchToTerminals,
|
||||
>
|
||||
{task.reviewReason === 'completed' ? 'Completed' :
|
||||
task.reviewReason === 'errors' ? 'Has Errors' :
|
||||
task.reviewReason === 'plan_review' ? 'Approve Plan' : 'QA Issues'}
|
||||
task.reviewReason === 'plan_review' ? 'Approve Plan' :
|
||||
task.reviewReason === 'stopped' ? 'Stopped' : 'QA Issues'}
|
||||
</Badge>
|
||||
)}
|
||||
</>
|
||||
@@ -406,6 +407,11 @@ function TaskDetailModalContent({ open, task, onOpenChange, onSwitchToTerminals,
|
||||
)}
|
||||
</div>
|
||||
</DialogPrimitive.Description>
|
||||
{window.DEBUG && (
|
||||
<div className="mt-1 text-[11px] text-muted-foreground font-mono">
|
||||
status={task.status} reviewReason={task.reviewReason ?? 'none'} phase={task.executionProgress?.phase ?? 'none'} reviewRequired={task.metadata?.requireReviewBeforeCoding ? 'true' : 'false'}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
<div className="flex items-center gap-1 shrink-0 electron-no-drag">
|
||||
<Button
|
||||
|
||||
@@ -87,7 +87,8 @@ export function TaskHeader({
|
||||
>
|
||||
{task.reviewReason === 'completed' ? 'Completed' :
|
||||
task.reviewReason === 'errors' ? 'Has Errors' :
|
||||
task.reviewReason === 'plan_review' ? 'Approve Plan' : 'QA Issues'}
|
||||
task.reviewReason === 'plan_review' ? 'Approve Plan' :
|
||||
task.reviewReason === 'stopped' ? 'Stopped' : 'QA Issues'}
|
||||
</Badge>
|
||||
)}
|
||||
</>
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+45
-5
@@ -1,7 +1,7 @@
|
||||
import { AlertCircle, GitMerge, Loader2, Check, RotateCcw } from 'lucide-react';
|
||||
import { AlertCircle, GitMerge, Loader2, Check, RotateCcw, Play } from 'lucide-react';
|
||||
import { useState } from 'react';
|
||||
import { Button } from '../../ui/button';
|
||||
import { persistTaskStatus } from '../../../stores/task-store';
|
||||
import { persistTaskStatus, startTask } from '../../../stores/task-store';
|
||||
import type { Task } from '../../../../shared/types';
|
||||
|
||||
interface LoadingMessageProps {
|
||||
@@ -32,6 +32,11 @@ interface NoWorkspaceMessageProps {
|
||||
*/
|
||||
export function NoWorkspaceMessage({ task, onClose }: NoWorkspaceMessageProps) {
|
||||
const [isMarkingDone, setIsMarkingDone] = useState(false);
|
||||
const [isProceeding, setIsProceeding] = useState(false);
|
||||
|
||||
const isPlanReview =
|
||||
task?.status === 'human_review' &&
|
||||
task.reviewReason === 'plan_review';
|
||||
|
||||
const handleMarkDone = async () => {
|
||||
if (!task) return;
|
||||
@@ -48,18 +53,53 @@ export function NoWorkspaceMessage({ task, onClose }: NoWorkspaceMessageProps) {
|
||||
}
|
||||
};
|
||||
|
||||
const handleProceedToCoding = async () => {
|
||||
if (!task) return;
|
||||
|
||||
setIsProceeding(true);
|
||||
try {
|
||||
await startTask(task.id);
|
||||
} catch (err) {
|
||||
console.error('Error proceeding to coding:', err);
|
||||
} finally {
|
||||
setIsProceeding(false);
|
||||
}
|
||||
};
|
||||
|
||||
return (
|
||||
<div className="rounded-xl border border-border bg-secondary/30 p-4">
|
||||
<h3 className="font-medium text-sm text-foreground mb-2 flex items-center gap-2">
|
||||
<AlertCircle className="h-4 w-4 text-muted-foreground" />
|
||||
No Workspace Found
|
||||
{isPlanReview ? 'Human Review Required' : 'No Workspace Found'}
|
||||
</h3>
|
||||
<p className="text-sm text-muted-foreground mb-3">
|
||||
No isolated workspace was found for this task. The changes may have been made directly in your project.
|
||||
{isPlanReview
|
||||
? 'Human review required prior to coding. Review your spec.md for any necessary changes.'
|
||||
: 'No isolated workspace was found for this task. The changes may have been made directly in your project.'}
|
||||
</p>
|
||||
|
||||
{/* Allow marking as done */}
|
||||
{task && task.status === 'human_review' && (
|
||||
{isPlanReview ? (
|
||||
<Button
|
||||
onClick={handleProceedToCoding}
|
||||
disabled={isProceeding}
|
||||
size="sm"
|
||||
variant="default"
|
||||
className="w-full"
|
||||
>
|
||||
{isProceeding ? (
|
||||
<>
|
||||
<Loader2 className="h-4 w-4 mr-2 animate-spin" />
|
||||
Updating...
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<Play className="h-4 w-4 mr-2" />
|
||||
Proceed to Coding
|
||||
</>
|
||||
)}
|
||||
</Button>
|
||||
) : task && task.status === 'human_review' && (
|
||||
<Button
|
||||
onClick={handleMarkDone}
|
||||
disabled={isMarkingDone}
|
||||
|
||||
@@ -14,6 +14,7 @@ import type { ImplementationPlan, TaskStatus, RoadmapGenerationStatus, Roadmap,
|
||||
*/
|
||||
interface BatchedUpdate {
|
||||
status?: TaskStatus;
|
||||
reviewReason?: import('../../shared/types').ReviewReason;
|
||||
progress?: ExecutionProgress;
|
||||
plan?: ImplementationPlan;
|
||||
logs?: string[]; // Batched log lines
|
||||
@@ -24,7 +25,7 @@ interface BatchedUpdate {
|
||||
* Store action references type for batch flushing.
|
||||
*/
|
||||
interface StoreActions {
|
||||
updateTaskStatus: (taskId: string, status: TaskStatus) => void;
|
||||
updateTaskStatus: (taskId: string, status: TaskStatus, reviewReason?: import('../../shared/types').ReviewReason) => void;
|
||||
updateExecutionProgress: (taskId: string, progress: ExecutionProgress) => void;
|
||||
updateTaskFromPlan: (taskId: string, plan: ImplementationPlan) => void;
|
||||
batchAppendLogs: (taskId: string, logs: string[]) => void;
|
||||
@@ -66,7 +67,7 @@ function flushBatch(): void {
|
||||
totalUpdates++;
|
||||
}
|
||||
if (updates.status) {
|
||||
actions.updateTaskStatus(taskId, updates.status);
|
||||
actions.updateTaskStatus(taskId, updates.status, updates.reviewReason);
|
||||
totalUpdates++;
|
||||
}
|
||||
if (updates.progress) {
|
||||
@@ -198,10 +199,17 @@ export function useIpcListeners(): void {
|
||||
);
|
||||
|
||||
const cleanupStatus = window.electronAPI.onTaskStatusChange(
|
||||
(taskId: string, status: TaskStatus, projectId?: string) => {
|
||||
(taskId: string, status: TaskStatus, projectId?: string, reviewReason?: import('../../shared/types').ReviewReason) => {
|
||||
// Debug: Log received status change
|
||||
console.log(`[useIpc] Received TASK_STATUS_CHANGE:`, {
|
||||
taskId,
|
||||
status,
|
||||
reviewReason,
|
||||
projectId
|
||||
});
|
||||
// Filter by project to prevent multi-project interference
|
||||
if (!isTaskForCurrentProject(projectId)) return;
|
||||
queueUpdate(taskId, { status });
|
||||
queueUpdate(taskId, { status, reviewReason });
|
||||
}
|
||||
);
|
||||
|
||||
|
||||
@@ -2,7 +2,6 @@ import { create } from 'zustand';
|
||||
import { arrayMove } from '@dnd-kit/sortable';
|
||||
import type { Task, TaskStatus, SubtaskStatus, ImplementationPlan, Subtask, TaskMetadata, ExecutionProgress, ExecutionPhase, ReviewReason, TaskDraft, ImageAttachment, TaskOrderState } from '../../shared/types';
|
||||
import { debugLog } from '../../shared/utils/debug-logger';
|
||||
import { isTerminalPhase } from '../../shared/constants/phase-protocol';
|
||||
|
||||
interface TaskState {
|
||||
tasks: Task[];
|
||||
@@ -15,7 +14,7 @@ interface TaskState {
|
||||
setTasks: (tasks: Task[]) => void;
|
||||
addTask: (task: Task) => void;
|
||||
updateTask: (taskId: string, updates: Partial<Task>) => void;
|
||||
updateTaskStatus: (taskId: string, status: TaskStatus) => void;
|
||||
updateTaskStatus: (taskId: string, status: TaskStatus, reviewReason?: ReviewReason) => void;
|
||||
updateTaskFromPlan: (taskId: string, plan: ImplementationPlan) => void;
|
||||
updateExecutionProgress: (taskId: string, progress: Partial<ExecutionProgress>) => void;
|
||||
appendLog: (taskId: string, log: string) => void;
|
||||
@@ -54,6 +53,39 @@ function findTaskIndex(tasks: Task[], taskId: string): number {
|
||||
*/
|
||||
const taskStatusChangeListeners = new Set<(taskId: string, oldStatus: TaskStatus | undefined, newStatus: TaskStatus) => void>();
|
||||
|
||||
/**
|
||||
* Track last activity timestamp per task for stuck detection.
|
||||
* If we've received activity (execution progress, status update) within a threshold,
|
||||
* the task is considered active even if the process check fails.
|
||||
* This prevents race conditions where stuck detection fires before process is registered.
|
||||
*/
|
||||
const taskLastActivity = new Map<string, number>();
|
||||
const STUCK_ACTIVITY_THRESHOLD_MS = 60_000; // 60 seconds — matches catastrophic stuck check interval
|
||||
|
||||
/**
|
||||
* Record activity for a task (call this when we receive execution progress or status updates)
|
||||
*/
|
||||
export function recordTaskActivity(taskId: string): void {
|
||||
taskLastActivity.set(taskId, Date.now());
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a task has had recent activity within the threshold.
|
||||
* Used by stuck detection to avoid false positives.
|
||||
*/
|
||||
export function hasRecentActivity(taskId: string): boolean {
|
||||
const lastActivity = taskLastActivity.get(taskId);
|
||||
if (!lastActivity) return false;
|
||||
return Date.now() - lastActivity < STUCK_ACTIVITY_THRESHOLD_MS;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear activity tracking for a task (call when task completes or is deleted)
|
||||
*/
|
||||
export function clearTaskActivity(taskId: string): void {
|
||||
taskLastActivity.delete(taskId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Notify all registered listeners when a task status changes
|
||||
*/
|
||||
@@ -201,7 +233,10 @@ export const useTaskStore = create<TaskState>((set, get) => ({
|
||||
};
|
||||
}),
|
||||
|
||||
updateTaskStatus: (taskId, status) => {
|
||||
updateTaskStatus: (taskId, status, reviewReason) => {
|
||||
// Record activity for stuck detection — status changes prove the task is alive
|
||||
recordTaskActivity(taskId);
|
||||
|
||||
// Capture old status before update
|
||||
const state = get();
|
||||
const index = findTaskIndex(state.tasks, taskId);
|
||||
@@ -319,136 +354,26 @@ export const useTaskStore = create<TaskState>((set, get) => ({
|
||||
}))
|
||||
});
|
||||
|
||||
const allCompleted = subtasks.every((s) => s.status === 'completed');
|
||||
const anyFailed = subtasks.some((s) => s.status === 'failed');
|
||||
const anyInProgress = subtasks.some((s) => s.status === 'in_progress');
|
||||
const anyCompleted = subtasks.some((s) => s.status === 'completed');
|
||||
|
||||
let status: TaskStatus = t.status;
|
||||
let reviewReason: ReviewReason | undefined = t.reviewReason;
|
||||
|
||||
// RACE CONDITION FIX: Don't let stale plan data override status during active execution
|
||||
// Strengthen guard: ANY active phase means NO status recalculation from plan data
|
||||
const activePhases: ExecutionPhase[] = ['planning', 'coding', 'qa_review', 'qa_fixing'];
|
||||
const isInActivePhase = Boolean(t.executionProgress?.phase && activePhases.includes(t.executionProgress.phase));
|
||||
|
||||
// FIX (Flip-Flop Bug): Terminal phases should NOT trigger status recalculation
|
||||
// When phase is 'complete' or 'failed', the task has finished and status should be stable
|
||||
const isInTerminalPhase = Boolean(t.executionProgress?.phase && isTerminalPhase(t.executionProgress.phase));
|
||||
|
||||
// FIX (Subtask 2-1): Terminal task statuses should NEVER be recalculated from plan data
|
||||
// pr_created, done, and error are finalized workflow states set by explicit user/system actions
|
||||
// Once a task reaches these statuses, they should only change via explicit user actions (like drag-drop)
|
||||
// This prevents stale plan file reads from incorrectly downgrading completed tasks
|
||||
// NOTE: Keep this in sync with TERMINAL_STATUSES in project-store.ts
|
||||
const TERMINAL_TASK_STATUSES: TaskStatus[] = ['pr_created', 'done', 'error'];
|
||||
const isInTerminalStatus = TERMINAL_TASK_STATUSES.includes(t.status);
|
||||
|
||||
// FIX (Flip-Flop Bug): Respect explicit human_review status from plan file
|
||||
// When the plan explicitly says 'human_review', don't override it with calculated status
|
||||
// Note: ImplementationPlan type already defines status?: TaskStatus
|
||||
const planStatus = plan.status;
|
||||
const isExplicitHumanReview = planStatus === 'human_review';
|
||||
|
||||
// FIX (ACS-203): Add defensive check for terminal status transitions
|
||||
// Before allowing transition to 'done', 'human_review', or 'ai_review', verify:
|
||||
// 1. Subtasks array is properly populated (not empty)
|
||||
// 2. All subtasks are actually completed (for 'done' and 'ai_review' statuses)
|
||||
const hasSubtasks = subtasks.length > 0;
|
||||
const terminalStatuses: TaskStatus[] = ['human_review', 'done'];
|
||||
|
||||
// If task is currently in a terminal status, validate subtasks before allowing downgrade
|
||||
// This prevents flip-flop when plan file is written with incomplete data
|
||||
const shouldBlockTerminalTransition = (newStatus: TaskStatus): boolean => {
|
||||
// Block if: moving to terminal status but subtasks indicate incomplete work
|
||||
if (terminalStatuses.includes(newStatus) || newStatus === 'ai_review') {
|
||||
// For ai_review, all subtasks must be completed
|
||||
if (newStatus === 'ai_review' && (!allCompleted || !hasSubtasks)) {
|
||||
return true;
|
||||
}
|
||||
// For done, all subtasks must be completed
|
||||
if (newStatus === 'done' && (!allCompleted || !hasSubtasks)) {
|
||||
return true;
|
||||
}
|
||||
// For human_review with 'completed' reason, all subtasks must be done
|
||||
// But allow 'errors' or 'qa_rejected' reasons even with incomplete subtasks
|
||||
if (newStatus === 'human_review' && anyFailed) {
|
||||
return false; // Allow human_review for failed subtasks
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
// Only recalculate status if:
|
||||
// 1. NOT in an active execution phase (planning, coding, qa_review, qa_fixing)
|
||||
// 2. NOT in a terminal phase (complete, failed) - status should be stable
|
||||
// 3. NOT in a terminal task status (pr_created, done) - finalized workflow states
|
||||
// 4. Plan doesn't explicitly say human_review
|
||||
// 5. Would not create an invalid terminal transition (ACS-203)
|
||||
if (!isInActivePhase && !isInTerminalPhase && !isInTerminalStatus && !isExplicitHumanReview) {
|
||||
if (allCompleted && hasSubtasks) {
|
||||
// FIX (Flip-Flop Bug): Don't downgrade from terminal statuses to ai_review
|
||||
// Once a task reaches human_review or done, it should stay there
|
||||
// unless explicitly changed (these are finalized workflow states)
|
||||
if (!terminalStatuses.includes(t.status)) {
|
||||
status = 'ai_review';
|
||||
}
|
||||
} else if (anyFailed) {
|
||||
status = 'human_review';
|
||||
reviewReason = 'errors';
|
||||
} else if (anyInProgress || anyCompleted) {
|
||||
status = 'in_progress';
|
||||
}
|
||||
}
|
||||
|
||||
// FIX (ACS-203): Final validation - prevent invalid terminal status transitions
|
||||
// This catches cases where the logic above would set a terminal status
|
||||
// but the subtask state doesn't support it (e.g., empty subtasks array)
|
||||
if (shouldBlockTerminalTransition(status)) {
|
||||
// Capture attempted status before reassignment for accurate logging
|
||||
const attemptedStatus = status;
|
||||
// Keep current status instead of transitioning to invalid terminal state
|
||||
status = t.status;
|
||||
debugLog('[updateTaskFromPlan] Blocked invalid terminal transition:', {
|
||||
taskId,
|
||||
attemptedStatus,
|
||||
currentStatus: t.status,
|
||||
hasSubtasks,
|
||||
allCompleted,
|
||||
anyFailed,
|
||||
subtaskCount: subtasks.length
|
||||
});
|
||||
}
|
||||
|
||||
debugLog('[updateTaskFromPlan] Status computation:', {
|
||||
taskId,
|
||||
currentStatus: t.status,
|
||||
newStatus: status,
|
||||
isInActivePhase,
|
||||
isInTerminalPhase,
|
||||
isInTerminalStatus,
|
||||
isExplicitHumanReview,
|
||||
planStatus,
|
||||
currentPhase: t.executionProgress?.phase,
|
||||
allCompleted,
|
||||
anyFailed,
|
||||
anyInProgress,
|
||||
anyCompleted
|
||||
});
|
||||
// NOTE: We do NOT update status from plan anymore.
|
||||
// XState is the source of truth for status - it emits TASK_STATUS_CHANGE.
|
||||
// Plan updates only update subtasks, title, and other non-status fields.
|
||||
// This prevents race conditions where a stale plan overwrites XState status.
|
||||
|
||||
return {
|
||||
...t,
|
||||
title: plan.feature || t.title,
|
||||
subtasks,
|
||||
status,
|
||||
reviewReason,
|
||||
// Keep existing status and reviewReason - XState manages these via TASK_STATUS_CHANGE
|
||||
updatedAt: new Date()
|
||||
};
|
||||
})
|
||||
};
|
||||
}),
|
||||
|
||||
updateExecutionProgress: (taskId, progress) =>
|
||||
updateExecutionProgress: (taskId, progress) => {
|
||||
// Record activity for stuck detection (outside of set() to avoid triggering extra renders)
|
||||
recordTaskActivity(taskId);
|
||||
|
||||
set((state) => {
|
||||
const index = findTaskIndex(state.tasks, taskId);
|
||||
if (index === -1) return state;
|
||||
@@ -492,7 +417,8 @@ export const useTaskStore = create<TaskState>((set, get) => ({
|
||||
};
|
||||
})
|
||||
};
|
||||
}),
|
||||
});
|
||||
},
|
||||
|
||||
appendLog: (taskId, log) =>
|
||||
set((state) => {
|
||||
@@ -508,8 +434,10 @@ export const useTaskStore = create<TaskState>((set, get) => ({
|
||||
}),
|
||||
|
||||
// Batch append multiple logs at once (single state update instead of N updates)
|
||||
batchAppendLogs: (taskId, logs) =>
|
||||
set((state) => {
|
||||
batchAppendLogs: (taskId, logs) => {
|
||||
// Record activity for stuck detection — log output proves the task is alive
|
||||
recordTaskActivity(taskId);
|
||||
return set((state) => {
|
||||
if (logs.length === 0) return state;
|
||||
const index = findTaskIndex(state.tasks, taskId);
|
||||
if (index === -1) return state;
|
||||
@@ -520,7 +448,8 @@ export const useTaskStore = create<TaskState>((set, get) => ({
|
||||
logs: [...(t.logs || []), ...logs]
|
||||
}))
|
||||
};
|
||||
}),
|
||||
});
|
||||
},
|
||||
|
||||
selectTask: (taskId) => set({ selectedTaskId: taskId }),
|
||||
|
||||
@@ -742,12 +671,9 @@ export async function submitReview(
|
||||
feedback?: string,
|
||||
images?: ImageAttachment[]
|
||||
): Promise<boolean> {
|
||||
const store = useTaskStore.getState();
|
||||
|
||||
try {
|
||||
const result = await window.electronAPI.submitReview(taskId, approved, feedback, images);
|
||||
if (result.success) {
|
||||
store.updateTaskStatus(taskId, approved ? 'done' : 'in_progress');
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@@ -878,14 +804,10 @@ export async function recoverStuckTask(
|
||||
taskId: string,
|
||||
options: { targetStatus?: TaskStatus; autoRestart?: boolean } = { autoRestart: true }
|
||||
): Promise<{ success: boolean; message: string; autoRestarted?: boolean }> {
|
||||
const store = useTaskStore.getState();
|
||||
|
||||
try {
|
||||
const result = await window.electronAPI.recoverStuckTask(taskId, options);
|
||||
|
||||
if (result.success && result.data) {
|
||||
// Update local state
|
||||
store.updateTaskStatus(taskId, result.data.newStatus);
|
||||
return {
|
||||
success: true,
|
||||
message: result.data.message,
|
||||
@@ -1133,7 +1055,8 @@ export function isIncompleteHumanReview(task: Task): boolean {
|
||||
if (task.status !== 'human_review') return false;
|
||||
|
||||
// JSON error tasks are intentionally in human_review with no subtasks - not incomplete
|
||||
if (task.reviewReason === 'errors') return false;
|
||||
// plan_review tasks are waiting for human approval before coding - not incomplete
|
||||
if (task.reviewReason === 'errors' || task.reviewReason === 'stopped' || task.reviewReason === 'plan_review') return false;
|
||||
|
||||
// If no subtasks defined, task hasn't been planned yet (shouldn't be in human_review)
|
||||
if (!task.subtasks || task.subtasks.length === 0) return true;
|
||||
|
||||
@@ -38,7 +38,8 @@
|
||||
"completed": "Completed",
|
||||
"hasErrors": "Has Errors",
|
||||
"qaIssues": "QA Issues",
|
||||
"approvePlan": "Approve Plan"
|
||||
"approvePlan": "Approve Plan",
|
||||
"stopped": "Stopped"
|
||||
},
|
||||
"tooltips": {
|
||||
"archiveTask": "Archive task",
|
||||
|
||||
@@ -37,7 +37,8 @@
|
||||
"completed": "Terminé",
|
||||
"hasErrors": "Contient des erreurs",
|
||||
"qaIssues": "Problèmes QA",
|
||||
"approvePlan": "Approuver le plan"
|
||||
"approvePlan": "Approuver le plan",
|
||||
"stopped": "Arrêté"
|
||||
},
|
||||
"tooltips": {
|
||||
"archiveTask": "Archiver la tâche",
|
||||
|
||||
@@ -0,0 +1,479 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { createActor } from 'xstate';
|
||||
import { taskMachine, type TaskEvent } from '../task-machine';
|
||||
|
||||
/**
|
||||
* Helper to run a sequence of events and get the final state
|
||||
*/
|
||||
function runEvents(events: TaskEvent[], initialState?: string) {
|
||||
const actor = initialState
|
||||
? createActor(taskMachine, {
|
||||
snapshot: taskMachine.resolveState({ value: initialState, context: {} })
|
||||
})
|
||||
: createActor(taskMachine);
|
||||
actor.start();
|
||||
|
||||
for (const event of events) {
|
||||
actor.send(event);
|
||||
}
|
||||
|
||||
const snapshot = actor.getSnapshot();
|
||||
actor.stop();
|
||||
return snapshot;
|
||||
}
|
||||
|
||||
describe('taskMachine', () => {
|
||||
describe('initial state', () => {
|
||||
it('should start in backlog state', () => {
|
||||
const actor = createActor(taskMachine);
|
||||
actor.start();
|
||||
expect(actor.getSnapshot().value).toBe('backlog');
|
||||
actor.stop();
|
||||
});
|
||||
|
||||
it('should have empty context initially', () => {
|
||||
const actor = createActor(taskMachine);
|
||||
actor.start();
|
||||
const snapshot = actor.getSnapshot();
|
||||
expect(snapshot.context.reviewReason).toBeUndefined();
|
||||
expect(snapshot.context.error).toBeUndefined();
|
||||
actor.stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('happy path: backlog → planning → coding → qa_review → human_review → done', () => {
|
||||
it('should transition through the standard workflow', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 3, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} },
|
||||
{ type: 'MARK_DONE' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('done');
|
||||
expect(snapshot.context.reviewReason).toBe('completed');
|
||||
});
|
||||
|
||||
it('should set reviewReason to completed when QA passes', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 3, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('completed');
|
||||
});
|
||||
});
|
||||
|
||||
describe('plan_review flow (requireReviewBeforeCoding: true)', () => {
|
||||
it('should go to plan_review when requireReviewBeforeCoding is true', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 3, requireReviewBeforeCoding: true }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('plan_review');
|
||||
expect(snapshot.context.reviewReason).toBe('plan_review');
|
||||
});
|
||||
|
||||
it('should transition from plan_review to coding on PLAN_APPROVED', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 3, requireReviewBeforeCoding: true },
|
||||
{ type: 'PLAN_APPROVED' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('coding');
|
||||
expect(snapshot.context.reviewReason).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should complete full flow with plan_review', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 3, requireReviewBeforeCoding: true },
|
||||
{ type: 'PLAN_APPROVED' },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} },
|
||||
{ type: 'MARK_DONE' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('done');
|
||||
});
|
||||
});
|
||||
|
||||
describe('QA fixing flow', () => {
|
||||
it('should transition to qa_fixing when QA fails', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_FAILED', iteration: 1, issueCount: 2, issues: ['issue1', 'issue2'] }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('qa_fixing');
|
||||
});
|
||||
|
||||
it('should go back to qa_review after qa_fixing completes', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_FAILED', iteration: 1, issueCount: 2, issues: ['issue1', 'issue2'] },
|
||||
{ type: 'QA_FIXING_COMPLETE', iteration: 1 }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('qa_review');
|
||||
});
|
||||
|
||||
it('should allow multiple QA fix iterations', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_FAILED', iteration: 1, issueCount: 2, issues: ['issue1'] },
|
||||
{ type: 'QA_FIXING_COMPLETE', iteration: 1 },
|
||||
{ type: 'QA_FAILED', iteration: 2, issueCount: 1, issues: ['issue1'] },
|
||||
{ type: 'QA_FIXING_COMPLETE', iteration: 2 },
|
||||
{ type: 'QA_PASSED', iteration: 3, testsRun: {} }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('completed');
|
||||
});
|
||||
});
|
||||
|
||||
describe('error states', () => {
|
||||
it('should transition to error on PLANNING_FAILED', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_FAILED', error: 'Test error', recoverable: false }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('error');
|
||||
expect(snapshot.context.reviewReason).toBe('errors');
|
||||
expect(snapshot.context.error).toBe('Test error');
|
||||
});
|
||||
|
||||
it('should transition to error on CODING_FAILED', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'CODING_FAILED', subtaskId: 'sub1', error: 'Coding error', attemptCount: 3 }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('error');
|
||||
expect(snapshot.context.reviewReason).toBe('errors');
|
||||
expect(snapshot.context.error).toBe('Coding error');
|
||||
});
|
||||
|
||||
it('should transition to error on QA_MAX_ITERATIONS from qa_review', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_MAX_ITERATIONS', iteration: 3, maxIterations: 3 }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('error');
|
||||
expect(snapshot.context.reviewReason).toBe('errors');
|
||||
});
|
||||
|
||||
it('should transition to error on QA_AGENT_ERROR', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_AGENT_ERROR', iteration: 1, consecutiveErrors: 3 }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('error');
|
||||
expect(snapshot.context.reviewReason).toBe('errors');
|
||||
});
|
||||
|
||||
it('should allow recovery from error via USER_RESUMED', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_FAILED', error: 'Test error', recoverable: true },
|
||||
{ type: 'USER_RESUMED' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('coding');
|
||||
expect(snapshot.context.reviewReason).toBeUndefined();
|
||||
expect(snapshot.context.error).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should allow MARK_DONE from error state', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_FAILED', error: 'Test error', recoverable: false },
|
||||
{ type: 'MARK_DONE' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('done');
|
||||
});
|
||||
});
|
||||
|
||||
describe('user stop/resume', () => {
|
||||
it('should go to backlog when stopped during planning with no plan', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'USER_STOPPED', hasPlan: false }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('backlog');
|
||||
});
|
||||
|
||||
it('should go to human_review when stopped during planning with plan', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'USER_STOPPED', hasPlan: true }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('stopped');
|
||||
});
|
||||
|
||||
it('should go to human_review when stopped during coding', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'USER_STOPPED' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('stopped');
|
||||
});
|
||||
|
||||
it('should go to human_review when stopped during qa_review', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'USER_STOPPED' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('stopped');
|
||||
});
|
||||
|
||||
it('should resume from human_review to coding', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'USER_STOPPED' },
|
||||
{ type: 'USER_RESUMED' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('coding');
|
||||
expect(snapshot.context.reviewReason).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('PR flow', () => {
|
||||
it('should transition to creating_pr on CREATE_PR', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} },
|
||||
{ type: 'CREATE_PR' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('creating_pr');
|
||||
});
|
||||
|
||||
it('should transition to pr_created on PR_CREATED', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} },
|
||||
{ type: 'CREATE_PR' },
|
||||
{ type: 'PR_CREATED', prUrl: 'https://github.com/test/pr/1' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('pr_created');
|
||||
});
|
||||
|
||||
it('should transition from pr_created to done on MARK_DONE', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} },
|
||||
{ type: 'CREATE_PR' },
|
||||
{ type: 'PR_CREATED', prUrl: 'https://github.com/test/pr/1' },
|
||||
{ type: 'MARK_DONE' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('done');
|
||||
});
|
||||
});
|
||||
|
||||
describe('unexpected process exit', () => {
|
||||
it('should go to error on unexpected process exit during planning', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PROCESS_EXITED', exitCode: 1, unexpected: true }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('error');
|
||||
expect(snapshot.context.reviewReason).toBe('errors');
|
||||
});
|
||||
|
||||
it('should go to error on unexpected process exit during coding', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'PROCESS_EXITED', exitCode: 1, unexpected: true }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('error');
|
||||
expect(snapshot.context.reviewReason).toBe('errors');
|
||||
});
|
||||
|
||||
it('should NOT go to error on expected process exit (unexpected=false)', () => {
|
||||
// Expected exit shouldn't trigger error state - the guard should fail
|
||||
const snapshot = runEvents(
|
||||
[{ type: 'PROCESS_EXITED', exitCode: 0, unexpected: false }],
|
||||
'coding'
|
||||
);
|
||||
|
||||
// Should stay in coding since guard fails
|
||||
expect(snapshot.value).toBe('coding');
|
||||
});
|
||||
});
|
||||
|
||||
describe('fallback transitions', () => {
|
||||
it('should allow CODING_STARTED from backlog (resumed task)', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'CODING_STARTED', subtaskId: 'sub1', subtaskDescription: 'Test' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('coding');
|
||||
});
|
||||
|
||||
it('should allow CODING_STARTED from planning (skipped PLANNING_COMPLETE)', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'CODING_STARTED', subtaskId: 'sub1', subtaskDescription: 'Test' }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('coding');
|
||||
});
|
||||
|
||||
it('should allow ALL_SUBTASKS_DONE from planning (fast task)', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'ALL_SUBTASKS_DONE', totalCount: 1 }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('qa_review');
|
||||
});
|
||||
|
||||
it('should allow QA_STARTED from planning (missed coding events)', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('qa_review');
|
||||
});
|
||||
|
||||
it('should allow QA_PASSED from planning (entire build completed quickly)', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('completed');
|
||||
});
|
||||
|
||||
it('should allow QA_PASSED from coding (missed QA_STARTED)', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_PASSED', iteration: 1, testsRun: {} }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('completed');
|
||||
});
|
||||
});
|
||||
|
||||
describe('qa_rejected flow', () => {
|
||||
it('should set reviewReason to qa_rejected when QA fails in qa_fixing', () => {
|
||||
const events: TaskEvent[] = [
|
||||
{ type: 'PLANNING_STARTED' },
|
||||
{ type: 'PLANNING_COMPLETE', hasSubtasks: true, subtaskCount: 1, requireReviewBeforeCoding: false },
|
||||
{ type: 'QA_STARTED', iteration: 1, maxIterations: 3 },
|
||||
{ type: 'QA_FAILED', iteration: 1, issueCount: 1, issues: ['issue'] },
|
||||
{ type: 'QA_FAILED', iteration: 2, issueCount: 1, issues: ['issue'] }
|
||||
];
|
||||
|
||||
const snapshot = runEvents(events);
|
||||
expect(snapshot.value).toBe('human_review');
|
||||
expect(snapshot.context.reviewReason).toBe('qa_rejected');
|
||||
});
|
||||
});
|
||||
|
||||
describe('state restoration from task', () => {
|
||||
it('should restore to correct state from existing task status', () => {
|
||||
// Test restoring to different states
|
||||
const testCases = [
|
||||
{ initialState: 'backlog', expectedState: 'backlog' },
|
||||
{ initialState: 'planning', expectedState: 'planning' },
|
||||
{ initialState: 'coding', expectedState: 'coding' },
|
||||
{ initialState: 'qa_review', expectedState: 'qa_review' },
|
||||
{ initialState: 'qa_fixing', expectedState: 'qa_fixing' },
|
||||
{ initialState: 'human_review', expectedState: 'human_review' },
|
||||
{ initialState: 'error', expectedState: 'error' },
|
||||
{ initialState: 'pr_created', expectedState: 'pr_created' },
|
||||
{ initialState: 'done', expectedState: 'done' }
|
||||
];
|
||||
|
||||
for (const { initialState, expectedState } of testCases) {
|
||||
const actor = createActor(taskMachine, {
|
||||
snapshot: taskMachine.resolveState({ value: initialState, context: {} })
|
||||
});
|
||||
actor.start();
|
||||
expect(actor.getSnapshot().value).toBe(expectedState);
|
||||
actor.stop();
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,2 @@
|
||||
export { taskMachine } from './task-machine';
|
||||
export type { TaskContext, TaskEvent } from './task-machine';
|
||||
@@ -0,0 +1,180 @@
|
||||
import { assign, createMachine } from 'xstate';
|
||||
import type { ReviewReason } from '../types';
|
||||
|
||||
export interface TaskContext {
|
||||
reviewReason?: ReviewReason;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export type TaskEvent =
|
||||
| { type: 'PLANNING_STARTED' }
|
||||
| {
|
||||
type: 'PLANNING_COMPLETE';
|
||||
hasSubtasks: boolean;
|
||||
subtaskCount: number;
|
||||
requireReviewBeforeCoding: boolean;
|
||||
}
|
||||
| { type: 'PLAN_APPROVED' }
|
||||
| { type: 'CODING_STARTED'; subtaskId: string; subtaskDescription: string }
|
||||
| { type: 'SUBTASK_COMPLETED'; subtaskId: string; completedCount: number; totalCount: number }
|
||||
| { type: 'ALL_SUBTASKS_DONE'; totalCount: number }
|
||||
| { type: 'QA_STARTED'; iteration: number; maxIterations: number }
|
||||
| { type: 'QA_PASSED'; iteration: number; testsRun: Record<string, unknown> }
|
||||
| { type: 'QA_FAILED'; iteration: number; issueCount: number; issues: string[] }
|
||||
| { type: 'QA_FIXING_STARTED'; iteration: number }
|
||||
| { type: 'QA_FIXING_COMPLETE'; iteration: number }
|
||||
| { type: 'PLANNING_FAILED'; error: string; recoverable: boolean }
|
||||
| { type: 'CODING_FAILED'; subtaskId: string; error: string; attemptCount: number }
|
||||
| { type: 'QA_MAX_ITERATIONS'; iteration: number; maxIterations: number }
|
||||
| { type: 'QA_AGENT_ERROR'; iteration: number; consecutiveErrors: number }
|
||||
| { type: 'PROCESS_EXITED'; exitCode: number; signal?: string; unexpected?: boolean }
|
||||
| { type: 'USER_STOPPED'; hasPlan?: boolean }
|
||||
| { type: 'USER_RESUMED' }
|
||||
| { type: 'MARK_DONE' }
|
||||
| { type: 'CREATE_PR' }
|
||||
| { type: 'PR_CREATED'; prUrl: string };
|
||||
|
||||
export const taskMachine = createMachine(
|
||||
{
|
||||
id: 'task',
|
||||
initial: 'backlog',
|
||||
types: {} as {
|
||||
context: TaskContext;
|
||||
events: TaskEvent;
|
||||
},
|
||||
context: {
|
||||
reviewReason: undefined,
|
||||
error: undefined
|
||||
},
|
||||
states: {
|
||||
backlog: {
|
||||
on: {
|
||||
PLANNING_STARTED: 'planning',
|
||||
// Fallback: if coding starts from backlog (e.g., resumed task), go to coding
|
||||
CODING_STARTED: 'coding',
|
||||
USER_STOPPED: 'backlog'
|
||||
}
|
||||
},
|
||||
planning: {
|
||||
on: {
|
||||
PLANNING_COMPLETE: [
|
||||
{
|
||||
target: 'plan_review',
|
||||
guard: 'requiresReview',
|
||||
actions: 'setReviewReasonPlan'
|
||||
},
|
||||
{ target: 'coding', actions: 'clearReviewReason' }
|
||||
],
|
||||
// Fallback: if CODING_STARTED arrives while in planning, transition to coding
|
||||
CODING_STARTED: { target: 'coding', actions: 'clearReviewReason' },
|
||||
// Fallback: if ALL_SUBTASKS_DONE arrives while in planning, go directly to qa_review
|
||||
ALL_SUBTASKS_DONE: 'qa_review',
|
||||
// Fallback: if QA_STARTED arrives while in planning, go to qa_review
|
||||
QA_STARTED: 'qa_review',
|
||||
// Fallback: if QA_PASSED arrives while in planning (entire build completed), go to human_review
|
||||
QA_PASSED: { target: 'human_review', actions: 'setReviewReasonCompleted' },
|
||||
PLANNING_FAILED: { target: 'error', actions: ['setReviewReasonErrors', 'setError'] },
|
||||
USER_STOPPED: [
|
||||
{ target: 'backlog', guard: 'noPlanYet', actions: 'clearReviewReason' },
|
||||
{ target: 'human_review', actions: 'setReviewReasonStopped' }
|
||||
],
|
||||
PROCESS_EXITED: { target: 'error', guard: 'unexpectedExit', actions: 'setReviewReasonErrors' }
|
||||
}
|
||||
},
|
||||
plan_review: {
|
||||
on: {
|
||||
PLAN_APPROVED: { target: 'coding', actions: 'clearReviewReason' },
|
||||
USER_STOPPED: { target: 'backlog', actions: 'clearReviewReason' },
|
||||
PROCESS_EXITED: { target: 'error', guard: 'unexpectedExit', actions: 'setReviewReasonErrors' }
|
||||
}
|
||||
},
|
||||
coding: {
|
||||
on: {
|
||||
QA_STARTED: 'qa_review',
|
||||
// ALL_SUBTASKS_DONE means coder finished but QA hasn't started yet
|
||||
// Transition to qa_review - QA will emit QA_PASSED or QA_FAILED
|
||||
ALL_SUBTASKS_DONE: 'qa_review',
|
||||
// Fallback: if QA_PASSED arrives while still in coding (missed QA_STARTED), go to human_review
|
||||
QA_PASSED: { target: 'human_review', actions: 'setReviewReasonCompleted' },
|
||||
CODING_FAILED: { target: 'error', actions: ['setReviewReasonErrors', 'setError'] },
|
||||
USER_STOPPED: { target: 'human_review', actions: 'setReviewReasonStopped' },
|
||||
PROCESS_EXITED: { target: 'error', guard: 'unexpectedExit', actions: 'setReviewReasonErrors' }
|
||||
}
|
||||
},
|
||||
qa_review: {
|
||||
on: {
|
||||
QA_FAILED: 'qa_fixing',
|
||||
QA_PASSED: { target: 'human_review', actions: 'setReviewReasonCompleted' },
|
||||
QA_MAX_ITERATIONS: { target: 'error', actions: 'setReviewReasonErrors' },
|
||||
QA_AGENT_ERROR: { target: 'error', actions: 'setReviewReasonErrors' },
|
||||
USER_STOPPED: { target: 'human_review', actions: 'setReviewReasonStopped' },
|
||||
PROCESS_EXITED: { target: 'error', guard: 'unexpectedExit', actions: 'setReviewReasonErrors' }
|
||||
}
|
||||
},
|
||||
qa_fixing: {
|
||||
on: {
|
||||
QA_FIXING_COMPLETE: 'qa_review',
|
||||
QA_FAILED: { target: 'human_review', actions: 'setReviewReasonQaRejected' },
|
||||
QA_PASSED: { target: 'human_review', actions: 'setReviewReasonCompleted' },
|
||||
QA_MAX_ITERATIONS: { target: 'error', actions: 'setReviewReasonErrors' },
|
||||
QA_AGENT_ERROR: { target: 'error', actions: 'setReviewReasonErrors' },
|
||||
USER_STOPPED: { target: 'human_review', actions: 'setReviewReasonStopped' },
|
||||
PROCESS_EXITED: { target: 'error', guard: 'unexpectedExit', actions: 'setReviewReasonErrors' }
|
||||
}
|
||||
},
|
||||
human_review: {
|
||||
on: {
|
||||
CREATE_PR: 'creating_pr',
|
||||
MARK_DONE: 'done',
|
||||
USER_RESUMED: { target: 'coding', actions: 'clearReviewReason' }
|
||||
}
|
||||
},
|
||||
error: {
|
||||
on: {
|
||||
USER_RESUMED: { target: 'coding', actions: 'clearReviewReason' },
|
||||
MARK_DONE: 'done'
|
||||
}
|
||||
},
|
||||
creating_pr: {
|
||||
on: {
|
||||
PR_CREATED: 'pr_created'
|
||||
}
|
||||
},
|
||||
pr_created: {
|
||||
on: {
|
||||
MARK_DONE: 'done'
|
||||
}
|
||||
},
|
||||
done: {
|
||||
type: 'final'
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
guards: {
|
||||
requiresReview: ({ event }) =>
|
||||
event.type === 'PLANNING_COMPLETE' && event.requireReviewBeforeCoding === true,
|
||||
noPlanYet: ({ event }) => event.type === 'USER_STOPPED' && event.hasPlan === false,
|
||||
unexpectedExit: ({ event }) => event.type === 'PROCESS_EXITED' && event.unexpected === true
|
||||
},
|
||||
actions: {
|
||||
setReviewReasonPlan: assign({ reviewReason: () => 'plan_review' }),
|
||||
setReviewReasonCompleted: assign({ reviewReason: () => 'completed' }),
|
||||
setReviewReasonStopped: assign({ reviewReason: () => 'stopped' }),
|
||||
setReviewReasonQaRejected: assign({ reviewReason: () => 'qa_rejected' }),
|
||||
setReviewReasonErrors: assign({ reviewReason: () => 'errors' }),
|
||||
clearReviewReason: assign({ reviewReason: () => undefined, error: () => undefined }),
|
||||
setError: assign({
|
||||
error: ({ event }) => {
|
||||
if (event.type === 'PLANNING_FAILED') {
|
||||
return event.error;
|
||||
}
|
||||
if (event.type === 'CODING_FAILED') {
|
||||
return event.error;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
);
|
||||
@@ -46,6 +46,7 @@ import type {
|
||||
TaskLogs,
|
||||
TaskLogStreamChunk,
|
||||
ImageAttachment,
|
||||
ReviewReason,
|
||||
MergeProgress
|
||||
} from './task';
|
||||
import type {
|
||||
@@ -199,11 +200,11 @@ export interface ElectronAPI {
|
||||
unarchiveTasks: (projectId: string, taskIds: string[]) => Promise<IPCResult<boolean>>;
|
||||
|
||||
// Event listeners
|
||||
onTaskProgress: (callback: (taskId: string, plan: ImplementationPlan) => void) => () => void;
|
||||
onTaskError: (callback: (taskId: string, error: string) => void) => () => void;
|
||||
onTaskLog: (callback: (taskId: string, log: string) => void) => () => void;
|
||||
onTaskStatusChange: (callback: (taskId: string, status: TaskStatus) => void) => () => void;
|
||||
onTaskExecutionProgress: (callback: (taskId: string, progress: ExecutionProgress) => void) => () => void;
|
||||
onTaskProgress: (callback: (taskId: string, plan: ImplementationPlan, projectId?: string) => void) => () => void;
|
||||
onTaskError: (callback: (taskId: string, error: string, projectId?: string) => void) => () => void;
|
||||
onTaskLog: (callback: (taskId: string, log: string, projectId?: string) => void) => () => void;
|
||||
onTaskStatusChange: (callback: (taskId: string, status: TaskStatus, projectId?: string, reviewReason?: ReviewReason) => void) => () => void;
|
||||
onTaskExecutionProgress: (callback: (taskId: string, progress: ExecutionProgress, projectId?: string) => void) => () => void;
|
||||
|
||||
// Terminal operations
|
||||
createTerminal: (options: TerminalCreateOptions) => Promise<IPCResult>;
|
||||
|
||||
@@ -15,7 +15,7 @@ export type TaskOrderState = Record<TaskStatus, string[]>;
|
||||
// - 'errors': Subtasks failed during execution
|
||||
// - 'qa_rejected': QA found issues that need fixing
|
||||
// - 'plan_review': Spec/plan created and awaiting approval before coding starts
|
||||
export type ReviewReason = 'completed' | 'errors' | 'qa_rejected' | 'plan_review';
|
||||
export type ReviewReason = 'completed' | 'errors' | 'qa_rejected' | 'plan_review' | 'stopped';
|
||||
|
||||
export type SubtaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
|
||||
|
||||
@@ -279,6 +279,14 @@ export interface ImplementationPlan {
|
||||
// Added for UI status persistence
|
||||
status?: TaskStatus;
|
||||
planStatus?: string;
|
||||
reviewReason?: ReviewReason;
|
||||
xstateState?: string; // Persisted XState machine state for restoration (e.g., 'planning', 'coding')
|
||||
lastEvent?: {
|
||||
eventId: string;
|
||||
sequence: number;
|
||||
type: string;
|
||||
timestamp: string;
|
||||
};
|
||||
recoveryNote?: string;
|
||||
description?: string;
|
||||
}
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
'card data'
|
||||
Generated
+42
-1
@@ -78,6 +78,7 @@
|
||||
"semver": "^7.7.3",
|
||||
"tailwind-merge": "^3.4.0",
|
||||
"uuid": "^13.0.0",
|
||||
"xstate": "^5.26.0",
|
||||
"zod": "^4.2.1",
|
||||
"zustand": "^5.0.9"
|
||||
},
|
||||
@@ -259,6 +260,7 @@
|
||||
"integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@babel/code-frame": "^7.28.6",
|
||||
"@babel/generator": "^7.28.6",
|
||||
@@ -823,6 +825,7 @@
|
||||
}
|
||||
],
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
},
|
||||
@@ -866,6 +869,7 @@
|
||||
}
|
||||
],
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
}
|
||||
@@ -905,6 +909,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@dnd-kit/core/-/core-6.3.1.tgz",
|
||||
"integrity": "sha512-xkGBRQQab4RLwgXxoqETICr6S5JlogafbhNsidmrkVv2YRs5MLwpjoF2qpiGjQt8S9AoxtIV603s0GIUpY5eYQ==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@dnd-kit/accessibility": "^3.1.1",
|
||||
"@dnd-kit/utilities": "^3.2.2",
|
||||
@@ -2191,6 +2196,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
|
||||
"integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=8.0.0"
|
||||
}
|
||||
@@ -2212,6 +2218,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@opentelemetry/context-async-hooks/-/context-async-hooks-2.4.0.tgz",
|
||||
"integrity": "sha512-jn0phJ+hU7ZuvaoZE/8/Euw3gvHJrn2yi+kXrymwObEPVPjtwCmkvXDRQCWli+fCTTF/aSOtXaLr7CLIvv3LQg==",
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": "^18.19.0 || >=20.6.0"
|
||||
},
|
||||
@@ -2224,6 +2231,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@opentelemetry/core/-/core-2.4.0.tgz",
|
||||
"integrity": "sha512-KtcyFHssTn5ZgDu6SXmUznS80OFs/wN7y6MyFRRcKU6TOw8hNcGxKvt8hsdaLJfhzUszNSjURetq5Qpkad14Gw==",
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@opentelemetry/semantic-conventions": "^1.29.0"
|
||||
},
|
||||
@@ -2239,6 +2247,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@opentelemetry/instrumentation/-/instrumentation-0.208.0.tgz",
|
||||
"integrity": "sha512-Eju0L4qWcQS+oXxi6pgh7zvE2byogAkcsVv0OjHF/97iOz1N/aKE6etSGowYkie+YA1uo6DNwdSxaaNnLvcRlA==",
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@opentelemetry/api-logs": "0.208.0",
|
||||
"import-in-the-middle": "^2.0.0",
|
||||
@@ -2641,6 +2650,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-2.4.0.tgz",
|
||||
"integrity": "sha512-RWvGLj2lMDZd7M/5tjkI/2VHMpXebLgPKvBUd9LRasEWR2xAynDwEYZuLvY9P2NGG73HF07jbbgWX2C9oavcQg==",
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@opentelemetry/core": "2.4.0",
|
||||
"@opentelemetry/semantic-conventions": "^1.29.0"
|
||||
@@ -2657,6 +2667,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.4.0.tgz",
|
||||
"integrity": "sha512-WH0xXkz/OHORDLKqaxcUZS0X+t1s7gGlumr2ebiEgNZQl2b0upK2cdoD0tatf7l8iP74woGJ/Kmxe82jdvcWRw==",
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@opentelemetry/core": "2.4.0",
|
||||
"@opentelemetry/resources": "2.4.0",
|
||||
@@ -2674,6 +2685,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.39.0.tgz",
|
||||
"integrity": "sha512-R5R9tb2AXs2IRLNKLBJDynhkfmx7mX0vi8NkhZb3gUkPWHn6HXk5J8iQ/dql0U3ApfWym4kXXmBDRGO+oeOfjg==",
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
@@ -4868,6 +4880,7 @@
|
||||
"integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@babel/code-frame": "^7.10.4",
|
||||
"@babel/runtime": "^7.12.5",
|
||||
@@ -5170,6 +5183,7 @@
|
||||
"resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.8.tgz",
|
||||
"integrity": "sha512-3MbSL37jEchWZz2p2mjntRZtPt837ij10ApxKfgmXCTuHWagYg7iA5bqPw6C8BMPfwidlvfPI/fxOc42HLhcyg==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"csstype": "^3.2.2"
|
||||
}
|
||||
@@ -5180,6 +5194,7 @@
|
||||
"integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
|
||||
"devOptional": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"peerDependencies": {
|
||||
"@types/react": "^19.2.0"
|
||||
}
|
||||
@@ -5449,6 +5464,7 @@
|
||||
"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
|
||||
"integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"bin": {
|
||||
"acorn": "bin/acorn"
|
||||
},
|
||||
@@ -5481,6 +5497,7 @@
|
||||
"integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"fast-deep-equal": "^3.1.1",
|
||||
"fast-json-stable-stringify": "^2.0.0",
|
||||
@@ -5951,6 +5968,7 @@
|
||||
}
|
||||
],
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"baseline-browser-mapping": "^2.9.0",
|
||||
"caniuse-lite": "^1.0.30001759",
|
||||
@@ -6921,6 +6939,7 @@
|
||||
"integrity": "sha512-ce4Ogns4VMeisIuCSK0C62umG0lFy012jd8LMZ6w/veHUeX4fqfDrGe+HTWALAEwK6JwKP+dhPvizhArSOsFbg==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"app-builder-lib": "26.4.0",
|
||||
"builder-util": "26.3.4",
|
||||
@@ -7078,6 +7097,7 @@
|
||||
"dev": true,
|
||||
"hasInstallScript": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@electron/get": "^2.0.0",
|
||||
"@types/node": "^24.9.0",
|
||||
@@ -8306,6 +8326,7 @@
|
||||
}
|
||||
],
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@babel/runtime": "^7.28.4"
|
||||
},
|
||||
@@ -8632,6 +8653,7 @@
|
||||
"integrity": "sha512-mjzqwWRD9Y1J1KUi7W97Gja1bwOOM5Ug0EZ6UDK3xS7j7mndrkwozHtSblfomlzyB4NepioNt+B2sOSzczVgtQ==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"@acemir/cssom": "^0.9.28",
|
||||
"@asamuzakjp/dom-selector": "^6.7.6",
|
||||
@@ -11118,6 +11140,7 @@
|
||||
}
|
||||
],
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"nanoid": "^3.3.11",
|
||||
"picocolors": "^1.1.1",
|
||||
@@ -11308,6 +11331,7 @@
|
||||
"resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
|
||||
"integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=0.10.0"
|
||||
}
|
||||
@@ -11317,6 +11341,7 @@
|
||||
"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.3.tgz",
|
||||
"integrity": "sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"scheduler": "^0.27.0"
|
||||
},
|
||||
@@ -12283,7 +12308,8 @@
|
||||
"version": "4.1.18",
|
||||
"resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.18.tgz",
|
||||
"integrity": "sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==",
|
||||
"license": "MIT"
|
||||
"license": "MIT",
|
||||
"peer": true
|
||||
},
|
||||
"node_modules/tapable": {
|
||||
"version": "2.3.0",
|
||||
@@ -12462,6 +12488,7 @@
|
||||
"integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=12"
|
||||
},
|
||||
@@ -12620,6 +12647,7 @@
|
||||
"integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
|
||||
"devOptional": true,
|
||||
"license": "Apache-2.0",
|
||||
"peer": true,
|
||||
"bin": {
|
||||
"tsc": "bin/tsc",
|
||||
"tsserver": "bin/tsserver"
|
||||
@@ -12926,6 +12954,7 @@
|
||||
"integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"esbuild": "^0.27.0",
|
||||
"fdir": "^6.5.0",
|
||||
@@ -13518,6 +13547,7 @@
|
||||
"integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=12"
|
||||
},
|
||||
@@ -13859,6 +13889,16 @@
|
||||
"dev": true,
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/xstate": {
|
||||
"version": "5.26.0",
|
||||
"resolved": "https://registry.npmjs.org/xstate/-/xstate-5.26.0.tgz",
|
||||
"integrity": "sha512-Fvi9VBoqHgsGYLU2NTag8xDTWtKqUC0+ue7EAhBNBb06wf620QEy05upBaEI1VLMzIn63zugLV8nHb69ZUWYAA==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/xstate"
|
||||
}
|
||||
},
|
||||
"node_modules/xtend": {
|
||||
"version": "4.0.2",
|
||||
"resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
|
||||
@@ -13962,6 +14002,7 @@
|
||||
"resolved": "https://registry.npmjs.org/zod/-/zod-4.3.5.tgz",
|
||||
"integrity": "sha512-k7Nwx6vuWx1IJ9Bjuf4Zt1PEllcwe7cls3VNzm4CQ1/hgtFUK2bRNG3rvnpPUhFjmqJKAKtjV576KnUkHocg/g==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"funding": {
|
||||
"url": "https://github.com/sponsors/colinhacks"
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user