feat: add portfolio rehearsal engine for Test Changes workflow

- Add PortfolioRehearsalEngine with simulation, stress tests, and recommendations
- Add route_test() method to WorkflowRouter and enable TEST task
- Add test_page UI with side-by-side comparison and impact analysis
- Add comprehensive test coverage (16 tests)

app.py

@@ -1954,13 +1954,12 @@ def create_interface() -> gr.Blocks:
                         size="lg"
                     )
 
-                # Test Changes - coming soon
+                # Test Changes
                 with gr.Column(scale=1, min_width=200):
                     task_test_btn = gr.Button(
-                        value="🔬\n\nTest Changes\n\nPreview impact before making portfolio changes\n\n🔒 Coming Soon",
+                        value="🔬\n\nTest Changes\n\nPreview impact before making portfolio changes",
                         elem_classes=["task-card"],
                         variant="secondary",
-                        interactive=False,
                         size="lg"
                     )
 
@@ -2088,6 +2087,90 @@ def create_interface() -> gr.Blocks:
                         with gr.Accordion("View Full Debate", open=False):
                             compare_debate_transcript = gr.JSON(label="Debate Rounds")
 
+        # Test Changes Page (shown when Test Changes task selected)
+        with gr.Group(visible=False, elem_classes="test-changes-container") as test_page:
+            gr.Markdown("## Test Portfolio Changes", elem_classes="section-title")
+            gr.Markdown("Preview the impact of changes before making them.")
+
+            with gr.Row(equal_height=True):
+                # Left column: Portfolio and changes input
+                with gr.Column(scale=2):
+                    with gr.Group(elem_classes="input-card"):
+                        test_portfolio_input = gr.Textbox(
+                            placeholder="AAPL 30%\nTSLA 25%\nNVDA 25%\nBND 20%",
+                            label="Current Portfolio (ticker weight%)",
+                            lines=6,
+                            info="Enter your current portfolio allocations"
+                        )
+
+                        test_changes_input = gr.Textbox(
+                            placeholder="sell TSLA 10\nbuy VTI 10",
+                            label="Proposed Changes",
+                            lines=4,
+                            info="Format: action ticker amount (e.g., 'sell TSLA 10' or 'buy VTI 15')"
+                        )
+
+                        test_portfolio_value = gr.Number(
+                            label="Portfolio Value ($)",
+                            value=100000,
+                            info="Total portfolio value for calculations"
+                        )
+
+                        with gr.Row():
+                            test_submit_btn = gr.Button(
+                                "Run Simulation",
+                                variant="primary",
+                                size="lg"
+                            )
+                            test_back_btn = gr.Button(
+                                "Back",
+                                variant="secondary",
+                                size="lg"
+                            )
+
+                # Right column: Results
+                with gr.Column(scale=3):
+                    with gr.Group(elem_classes="preview-card", visible=False) as test_results_container:
+                        test_status = gr.Markdown("", elem_classes="test-status")
+
+                        # Side-by-side metrics comparison
+                        with gr.Row():
+                            with gr.Column():
+                                gr.Markdown("### Current Portfolio")
+                                test_current_metrics = gr.Dataframe(
+                                    headers=["Metric", "Value"],
+                                    label="Current Metrics",
+                                    interactive=False
+                                )
+
+                            with gr.Column():
+                                gr.Markdown("### After Changes")
+                                test_simulated_metrics = gr.Dataframe(
+                                    headers=["Metric", "Value"],
+                                    label="Simulated Metrics",
+                                    interactive=False
+                                )
+
+                        # Impact summary
+                        gr.Markdown("### Impact Analysis")
+                        test_impact_summary = gr.Dataframe(
+                            headers=["Metric", "Current", "Simulated", "Change", "% Change"],
+                            label="Impact Summary",
+                            interactive=False
+                        )
+
+                        # Stress test comparison
+                        with gr.Accordion("Stress Test Comparison", open=False):
+                            test_stress_comparison = gr.Dataframe(
+                                headers=["Scenario", "Shock %", "Current Loss", "Simulated Loss", "Improvement"],
+                                label="Stress Tests",
+                                interactive=False
+                            )
+
+                        # Recommendations and assessment
+                        test_assessment = gr.Markdown("", elem_classes="test-assessment")
+                        test_recommendations = gr.Markdown("", label="Recommendations")
+
         # Input Page with side-by-side layout (hidden until authenticated)
         with gr.Group(visible=False) as input_page:
             # Side-by-side input and preview (2:3 ratio for wider preview)
@@ -2526,7 +2609,8 @@ def create_interface() -> gr.Blocks:
                 results_page: gr.update(visible=False),
                 history_page: gr.update(visible=False),
                 build_page: gr.update(visible=False),
-                compare_page: gr.update(visible=False)
+                compare_page: gr.update(visible=False),
+                test_page: gr.update(visible=False)
             }
 
         def show_task_page():
@@ -2536,7 +2620,8 @@ def create_interface() -> gr.Blocks:
                 results_page: gr.update(visible=False),
                 history_page: gr.update(visible=False),
                 build_page: gr.update(visible=False),
-                compare_page: gr.update(visible=False)
+                compare_page: gr.update(visible=False),
+                test_page: gr.update(visible=False)
             }
 
         def show_build_page():
@@ -2546,7 +2631,8 @@ def create_interface() -> gr.Blocks:
                 results_page: gr.update(visible=False),
                 history_page: gr.update(visible=False),
                 build_page: gr.update(visible=True),
-                compare_page: gr.update(visible=False)
+                compare_page: gr.update(visible=False),
+                test_page: gr.update(visible=False)
             }
 
         def show_compare_page():
@@ -2556,7 +2642,19 @@ def create_interface() -> gr.Blocks:
                 results_page: gr.update(visible=False),
                 history_page: gr.update(visible=False),
                 build_page: gr.update(visible=False),
-                compare_page: gr.update(visible=True)
+                compare_page: gr.update(visible=True),
+                test_page: gr.update(visible=False)
+            }
+
+        def show_test_page():
+            return {
+                task_page: gr.update(visible=False),
+                input_page: gr.update(visible=False),
+                results_page: gr.update(visible=False),
+                history_page: gr.update(visible=False),
+                build_page: gr.update(visible=False),
+                compare_page: gr.update(visible=False),
+                test_page: gr.update(visible=True)
             }
 
         async def handle_build_portfolio(goals, risk_tolerance, constraints, show_reasoning, session_state):
@@ -2658,7 +2756,8 @@ def create_interface() -> gr.Blocks:
                     gr.update(visible=False),  # results_page
                     gr.update(visible=False),  # history_page
                     gr.update(visible=False),  # build_page
-                    gr.update(visible=False)  # compare_page
+                    gr.update(visible=False),  # compare_page
+                    gr.update(visible=False)  # test_page
                 )
 
             # Convert portfolio table to input format
@@ -2678,7 +2777,8 @@ def create_interface() -> gr.Blocks:
                 gr.update(visible=False),  # results_page
                 gr.update(visible=False),  # history_page
                 gr.update(visible=False),  # build_page
-                gr.update(visible=False)  # compare_page
+                gr.update(visible=False),  # compare_page
+                gr.update(visible=False)  # test_page
             )
 
         async def handle_compare_portfolio(portfolio_text, session_state):
@@ -2754,6 +2854,187 @@ def create_interface() -> gr.Blocks:
             """Synchronous wrapper for handle_compare_portfolio."""
             return asyncio.run(handle_compare_portfolio(portfolio_text, session_state))
 
+        async def handle_test_changes(portfolio_text, changes_text, portfolio_value, session_state):
+            """Handle the Test Changes workflow.
+
+            Args:
+                portfolio_text: Current portfolio as text (ticker weight%)
+                changes_text: Proposed changes as text
+                portfolio_value: Total portfolio value
+                session_state: User session
+
+            Returns:
+                Tuple of UI updates for test results
+            """
+            try:
+                if not portfolio_text.strip():
+                    return (
+                        gr.update(visible=True),
+                        "Please enter your current portfolio.",
+                        [],
+                        [],
+                        [],
+                        [],
+                        "",
+                        ""
+                    )
+
+                if not changes_text.strip():
+                    return (
+                        gr.update(visible=True),
+                        "Please enter proposed changes.",
+                        [],
+                        [],
+                        [],
+                        [],
+                        "",
+                        ""
+                    )
+
+                # Parse current portfolio
+                current_portfolio = {}
+                for line in portfolio_text.strip().split("\n"):
+                    line = line.strip()
+                    if not line:
+                        continue
+                    parts = line.replace("%", "").split()
+                    if len(parts) >= 2:
+                        ticker = parts[0].upper()
+                        try:
+                            weight = float(parts[1])
+                            current_portfolio[ticker] = {"weight": weight}
+                        except ValueError:
+                            continue
+
+                # Parse proposed changes
+                proposed_changes = []
+                for line in changes_text.strip().split("\n"):
+                    line = line.strip().lower()
+                    if not line:
+                        continue
+                    parts = line.split()
+                    if len(parts) >= 3:
+                        action = parts[0]
+                        ticker = parts[1].upper()
+                        try:
+                            amount = float(parts[2])
+                            if action in ["buy", "sell"]:
+                                proposed_changes.append({
+                                    "action": action,
+                                    "ticker": ticker,
+                                    "amount": amount
+                                })
+                        except ValueError:
+                            continue
+
+                if not current_portfolio:
+                    return (
+                        gr.update(visible=True),
+                        "Could not parse portfolio. Use format: TICKER WEIGHT%",
+                        [],
+                        [],
+                        [],
+                        [],
+                        "",
+                        ""
+                    )
+
+                if not proposed_changes:
+                    return (
+                        gr.update(visible=True),
+                        "Could not parse changes. Use format: buy/sell TICKER AMOUNT",
+                        [],
+                        [],
+                        [],
+                        [],
+                        "",
+                        ""
+                    )
+
+                # Initialise MCP router and workflow router
+                from backend.mcp_router import MCPRouter
+                from backend.agents.workflow_router import WorkflowRouter
+
+                mcp_router = MCPRouter()
+                workflow_router = WorkflowRouter(mcp_router)
+
+                # Run the test workflow
+                result = await workflow_router.route_test(
+                    current_portfolio=current_portfolio,
+                    proposed_changes=proposed_changes,
+                    portfolio_value=float(portfolio_value)
+                )
+
+                # Format current metrics for display
+                current_metrics_data = []
+                for metric, value in result.get("current", {}).get("metrics", {}).items():
+                    if isinstance(value, (int, float)):
+                        current_metrics_data.append([metric.replace("_", " ").title(), f"{value:.4f}"])
+
+                # Format simulated metrics for display
+                simulated_metrics_data = []
+                for metric, value in result.get("simulated", {}).get("metrics", {}).items():
+                    if isinstance(value, (int, float)):
+                        simulated_metrics_data.append([metric.replace("_", " ").title(), f"{value:.4f}"])
+
+                # Format impact summary
+                impact_data = []
+                for metric, impact in result.get("impact", {}).items():
+                    impact_data.append([
+                        metric.replace("_", " ").title(),
+                        f"{impact.get('current', 0):.4f}",
+                        f"{impact.get('simulated', 0):.4f}",
+                        f"{impact.get('delta', 0):+.4f}",
+                        f"{impact.get('pct_change', 0):+.2f}%"
+                    ])
+
+                # Format stress test comparison
+                stress_data = []
+                for scenario, data in result.get("stress_comparison", {}).items():
+                    stress_data.append([
+                        scenario.replace("_", " ").title(),
+                        f"{data.get('shock', 0):.0f}%",
+                        f"${data.get('current_loss', 0):,.0f}",
+                        f"${data.get('simulated_loss', 0):,.0f}",
+                        f"${data.get('improvement', 0):+,.0f}"
+                    ])
+
+                # Format recommendations
+                recommendations_text = "### Recommendations\n\n"
+                for rec in result.get("recommendations", []):
+                    recommendations_text += f"- {rec}\n"
+
+                # Format assessment
+                assessment_text = f"### Overall Assessment\n\n**{result.get('overall_assessment', 'No assessment')}**"
+
+                return (
+                    gr.update(visible=True),
+                    "Simulation complete!",
+                    current_metrics_data,
+                    simulated_metrics_data,
+                    impact_data,
+                    stress_data,
+                    assessment_text,
+                    recommendations_text
+                )
+
+            except Exception as e:
+                logger.error(f"Test changes error: {e}")
+                return (
+                    gr.update(visible=True),
+                    f"Error running simulation: {str(e)}",
+                    [],
+                    [],
+                    [],
+                    [],
+                    "",
+                    ""
+                )
+
+        def sync_handle_test_changes(portfolio_text, changes_text, portfolio_value, session_state):
+            """Synchronous wrapper for handle_test_changes."""
+            return asyncio.run(handle_test_changes(portfolio_text, changes_text, portfolio_value, session_state))
+
         async def load_history(session_state):
             """Load analysis history from database.
 
@@ -3824,29 +4105,34 @@ Please try again with different parameters.
         # Navigation event handlers
         nav_new_analysis.click(
             show_task_page,
-            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
         )
 
         # Task card event handlers
         task_analyse_btn.click(
             show_input_page,
-            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
         )
 
         task_build_btn.click(
             show_build_page,
-            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
         )
 
         task_compare_btn.click(
             show_compare_page,
-            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
+        )
+
+        task_test_btn.click(
+            show_test_page,
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
         )
 
         # Build page event handlers
         build_back_btn.click(
             show_task_page,
-            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
         )
 
         build_submit_btn.click(
@@ -3871,7 +4157,7 @@ Please try again with different parameters.
         build_accept_btn.click(
             handle_build_accept,
             inputs=[build_portfolio_table],
-            outputs=[portfolio_input, task_page, input_page, results_page, history_page, build_page, compare_page]
+            outputs=[portfolio_input, task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
         )
 
         build_regenerate_btn.click(
@@ -3890,7 +4176,7 @@ Please try again with different parameters.
         # Compare page event handlers
         compare_back_btn.click(
             show_task_page,
-            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
         )
 
         compare_submit_btn.click(
@@ -3909,6 +4195,27 @@ Please try again with different parameters.
             ]
         )
 
+        # Test page event handlers
+        test_back_btn.click(
+            show_task_page,
+            outputs=[task_page, input_page, results_page, history_page, build_page, compare_page, test_page]
+        )
+
+        test_submit_btn.click(
+            sync_handle_test_changes,
+            inputs=[test_portfolio_input, test_changes_input, test_portfolio_value, session_state],
+            outputs=[
+                test_results_container,
+                test_status,
+                test_current_metrics,
+                test_simulated_metrics,
+                test_impact_summary,
+                test_stress_comparison,
+                test_assessment,
+                test_recommendations
+            ]
+        )
+
         nav_view_history.click(
             show_history_page,
             outputs=[task_page, input_page, results_page, history_page]

backend/agents/rehearsal.py

@@ -0,0 +1,484 @@
+"""Portfolio rehearsal engine for testing changes before execution.
+
+Simulates portfolio changes and provides side-by-side impact comparison.
+"""
+
+import asyncio
+import logging
+from decimal import Decimal
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class PortfolioRehearsalEngine:
+    """Simulates portfolio changes before execution.
+
+    Provides side-by-side comparison of:
+    - Current vs proposed metrics
+    - Risk impact
+    - Expected return changes
+    - Diversification effects
+    """
+
+    def __init__(self, mcp_router):
+        """Initialise the rehearsal engine.
+
+        Args:
+            mcp_router: MCP router instance for calling MCP servers
+        """
+        self.mcp_router = mcp_router
+
+    async def rehearse_changes(
+        self,
+        current_portfolio: Dict[str, Dict[str, Any]],
+        proposed_changes: List[Dict[str, Any]],
+        portfolio_value: float = 100000.0
+    ) -> Dict[str, Any]:
+        """Simulate impact of proposed portfolio changes.
+
+        Args:
+            current_portfolio: {ticker: {weight: float, shares: int, value: float}}
+            proposed_changes: [{action: buy/sell, ticker: str, amount: float}]
+            portfolio_value: Total portfolio value for calculations
+
+        Returns:
+            Comparison metrics and recommendations
+        """
+        logger.info(f"Rehearsing changes for portfolio with {len(current_portfolio)} holdings")
+
+        simulated_portfolio = self._apply_changes(current_portfolio, proposed_changes)
+
+        all_tickers = set(current_portfolio.keys()) | set(simulated_portfolio.keys())
+        historical_data = await self._fetch_historical_data(list(all_tickers))
+
+        current_analysis, simulated_analysis = await asyncio.gather(
+            self._analyse_portfolio(current_portfolio, historical_data, portfolio_value),
+            self._analyse_portfolio(simulated_portfolio, historical_data, portfolio_value)
+        )
+
+        impact = self._calculate_impact(current_analysis, simulated_analysis)
+
+        stress_comparison = await self._compare_stress_tests(
+            current_portfolio,
+            simulated_portfolio,
+            historical_data,
+            portfolio_value
+        )
+
+        recommendations = self._generate_recommendations(impact, stress_comparison)
+
+        overall_assessment = self._assess_changes(impact)
+
+        return {
+            "current": {
+                "portfolio": current_portfolio,
+                "metrics": current_analysis
+            },
+            "simulated": {
+                "portfolio": simulated_portfolio,
+                "metrics": simulated_analysis
+            },
+            "impact": impact,
+            "stress_comparison": stress_comparison,
+            "recommendations": recommendations,
+            "overall_assessment": overall_assessment
+        }
+
+    def _apply_changes(
+        self,
+        portfolio: Dict[str, Dict[str, Any]],
+        changes: List[Dict[str, Any]]
+    ) -> Dict[str, Dict[str, Any]]:
+        """Apply proposed changes to create simulated portfolio.
+
+        Args:
+            portfolio: Current portfolio holdings
+            changes: List of proposed changes
+
+        Returns:
+            New portfolio with changes applied
+        """
+        new_portfolio = {
+            ticker: data.copy()
+            for ticker, data in portfolio.items()
+        }
+
+        for change in changes:
+            ticker = change["ticker"]
+            action = change["action"]
+            amount = change["amount"]
+
+            if action == "sell":
+                if ticker in new_portfolio:
+                    new_portfolio[ticker]["weight"] -= amount
+                    if new_portfolio[ticker]["weight"] <= 0:
+                        del new_portfolio[ticker]
+
+            elif action == "buy":
+                if ticker in new_portfolio:
+                    new_portfolio[ticker]["weight"] += amount
+                else:
+                    new_portfolio[ticker] = {"weight": amount}
+
+        total_weight = sum(h["weight"] for h in new_portfolio.values())
+        if total_weight > 0:
+            for ticker in new_portfolio:
+                new_portfolio[ticker]["weight"] = (
+                    new_portfolio[ticker]["weight"] / total_weight * 100
+                )
+
+        return new_portfolio
+
+    async def _fetch_historical_data(
+        self,
+        tickers: List[str]
+    ) -> Dict[str, Dict[str, Any]]:
+        """Fetch historical price data for all tickers.
+
+        Args:
+            tickers: List of ticker symbols
+
+        Returns:
+            Historical data keyed by ticker
+        """
+        logger.info(f"Fetching historical data for {len(tickers)} tickers")
+
+        async def fetch_ticker(ticker: str) -> tuple[str, Dict[str, Any]]:
+            try:
+                result = await self.mcp_router.call_yahoo_finance_mcp(
+                    "get_historical_data",
+                    {"ticker": ticker, "period": "1y", "interval": "1d"}
+                )
+                return ticker, result
+            except Exception as e:
+                logger.warning(f"Failed to fetch historical data for {ticker}: {e}")
+                return ticker, {"close_prices": [], "error": str(e)}
+
+        results = await asyncio.gather(*[fetch_ticker(t) for t in tickers])
+        return dict(results)
+
+    async def _analyse_portfolio(
+        self,
+        portfolio: Dict[str, Dict[str, Any]],
+        historical_data: Dict[str, Dict[str, Any]],
+        portfolio_value: float
+    ) -> Dict[str, Any]:
+        """Run full analysis on a portfolio.
+
+        Args:
+            portfolio: Portfolio holdings
+            historical_data: Historical price data
+            portfolio_value: Total portfolio value
+
+        Returns:
+            Analysis metrics
+        """
+        if not portfolio:
+            return {
+                "expected_return": 0.0,
+                "var_95": 0.0,
+                "cvar_95": 0.0,
+                "volatility": 0.0,
+                "sharpe_ratio": 0.0,
+                "diversification": 0.0,
+                "max_drawdown": 0.0,
+                "num_holdings": 0
+            }
+
+        portfolio_inputs = []
+        for ticker, data in portfolio.items():
+            if ticker in historical_data and "close_prices" in historical_data[ticker]:
+                prices = historical_data[ticker].get("close_prices", [])
+                if prices:
+                    portfolio_inputs.append({
+                        "ticker": ticker,
+                        "weight": Decimal(str(data["weight"] / 100)),
+                        "prices": [Decimal(str(p)) for p in prices]
+                    })
+
+        if not portfolio_inputs:
+            return {
+                "expected_return": 0.0,
+                "var_95": 0.0,
+                "cvar_95": 0.0,
+                "volatility": 0.0,
+                "sharpe_ratio": 0.0,
+                "diversification": 0.0,
+                "max_drawdown": 0.0,
+                "num_holdings": len(portfolio)
+            }
+
+        try:
+            risk_result = await self.mcp_router.call_risk_analyzer_mcp(
+                "analyze_risk",
+                {
+                    "portfolio": portfolio_inputs,
+                    "portfolio_value": Decimal(str(portfolio_value)),
+                    "confidence_level": Decimal("0.95"),
+                    "time_horizon": 1,
+                    "method": "historical"
+                }
+            )
+        except Exception as e:
+            logger.warning(f"Risk analysis failed: {e}")
+            risk_result = {}
+
+        expected_return = self._calculate_expected_return(portfolio, historical_data)
+
+        weights = [data["weight"] / 100 for data in portfolio.values()]
+        herfindahl = sum(w ** 2 for w in weights)
+        diversification = 1 - herfindahl
+
+        return {
+            "expected_return": expected_return,
+            "var_95": float(risk_result.get("var_percentage", 0)),
+            "cvar_95": float(risk_result.get("cvar_percentage", 0)),
+            "volatility": float(risk_result.get("portfolio_volatility", 0)),
+            "sharpe_ratio": float(risk_result.get("sharpe_ratio", 0)),
+            "diversification": diversification,
+            "max_drawdown": float(risk_result.get("max_drawdown", 0)),
+            "num_holdings": len(portfolio)
+        }
+
+    def _calculate_expected_return(
+        self,
+        portfolio: Dict[str, Dict[str, Any]],
+        historical_data: Dict[str, Dict[str, Any]]
+    ) -> float:
+        """Calculate expected portfolio return based on historical data.
+
+        Args:
+            portfolio: Portfolio holdings
+            historical_data: Historical price data
+
+        Returns:
+            Expected annual return as percentage
+        """
+        total_return = 0.0
+        total_weight = 0.0
+
+        for ticker, data in portfolio.items():
+            if ticker in historical_data:
+                prices = historical_data[ticker].get("close_prices", [])
+                if len(prices) >= 2:
+                    annual_return = ((prices[-1] - prices[0]) / prices[0]) * 100
+                    weight = data["weight"] / 100
+                    total_return += annual_return * weight
+                    total_weight += weight
+
+        return total_return if total_weight > 0 else 0.0
+
+    def _calculate_impact(
+        self,
+        current: Dict[str, Any],
+        simulated: Dict[str, Any]
+    ) -> Dict[str, Dict[str, Any]]:
+        """Calculate impact deltas between portfolios.
+
+        Args:
+            current: Current portfolio metrics
+            simulated: Simulated portfolio metrics
+
+        Returns:
+            Impact metrics with current, simulated, delta, and pct_change
+        """
+        impact = {}
+        for metric in current:
+            if isinstance(current[metric], (int, float)):
+                current_val = current[metric]
+                simulated_val = simulated[metric]
+                delta = simulated_val - current_val
+                pct_change = (delta / current_val * 100) if current_val != 0 else 0
+
+                impact[metric] = {
+                    "current": current_val,
+                    "simulated": simulated_val,
+                    "delta": delta,
+                    "pct_change": pct_change
+                }
+
+        return impact
+
+    async def _compare_stress_tests(
+        self,
+        current_portfolio: Dict[str, Dict[str, Any]],
+        simulated_portfolio: Dict[str, Dict[str, Any]],
+        historical_data: Dict[str, Dict[str, Any]],
+        portfolio_value: float
+    ) -> Dict[str, Any]:
+        """Compare stress test results between portfolios.
+
+        Args:
+            current_portfolio: Current portfolio
+            simulated_portfolio: Simulated portfolio
+            historical_data: Historical price data
+            portfolio_value: Total portfolio value
+
+        Returns:
+            Stress test comparison results
+        """
+        scenarios = {
+            "market_crash": -0.20,
+            "correction": -0.10,
+            "mild_decline": -0.05
+        }
+
+        results = {}
+        for scenario_name, shock in scenarios.items():
+            current_impact = self._apply_market_shock(
+                current_portfolio, historical_data, shock, portfolio_value
+            )
+            simulated_impact = self._apply_market_shock(
+                simulated_portfolio, historical_data, shock, portfolio_value
+            )
+
+            results[scenario_name] = {
+                "shock": shock * 100,
+                "current_loss": current_impact,
+                "simulated_loss": simulated_impact,
+                "improvement": current_impact - simulated_impact
+            }
+
+        return results
+
+    def _apply_market_shock(
+        self,
+        portfolio: Dict[str, Dict[str, Any]],
+        historical_data: Dict[str, Dict[str, Any]],
+        shock: float,
+        portfolio_value: float
+    ) -> float:
+        """Calculate portfolio loss under market shock scenario.
+
+        Args:
+            portfolio: Portfolio holdings
+            historical_data: Historical price data
+            shock: Market shock as decimal (-0.20 = 20% crash)
+            portfolio_value: Total portfolio value
+
+        Returns:
+            Loss amount in currency
+        """
+        total_loss = 0.0
+        for ticker, data in portfolio.items():
+            weight = data["weight"] / 100
+            beta = self._estimate_beta(ticker, historical_data)
+            ticker_loss = portfolio_value * weight * shock * beta
+            total_loss += ticker_loss
+
+        return abs(total_loss)
+
+    def _estimate_beta(
+        self,
+        ticker: str,
+        historical_data: Dict[str, Dict[str, Any]]
+    ) -> float:
+        """Estimate beta for a ticker (simplified).
+
+        Args:
+            ticker: Ticker symbol
+            historical_data: Historical price data
+
+        Returns:
+            Estimated beta (defaults to 1.0)
+        """
+        high_beta_tickers = {"TSLA", "NVDA", "AMD", "MSTR", "COIN"}
+        low_beta_tickers = {"BND", "TLT", "VGSH", "GLD", "VNQ"}
+
+        if ticker in high_beta_tickers:
+            return 1.5
+        elif ticker in low_beta_tickers:
+            return 0.5
+        else:
+            return 1.0
+
+    def _generate_recommendations(
+        self,
+        impact: Dict[str, Dict[str, Any]],
+        stress: Dict[str, Any]
+    ) -> List[str]:
+        """Generate actionable recommendations based on impact.
+
+        Args:
+            impact: Impact metrics
+            stress: Stress test results
+
+        Returns:
+            List of recommendation strings
+        """
+        recommendations = []
+
+        var_change = impact.get("var_95", {}).get("pct_change", 0)
+        if var_change < -10:
+            recommendations.append("Risk reduction: VaR decreased significantly")
+        elif var_change > 10:
+            recommendations.append("Risk increase: VaR increased significantly - consider reviewing")
+
+        return_change = impact.get("expected_return", {}).get("pct_change", 0)
+        if return_change > 5:
+            recommendations.append("Return improvement: Expected returns increased")
+        elif return_change < -5:
+            recommendations.append("Return reduction: Expected returns decreased")
+
+        sharpe_change = impact.get("sharpe_ratio", {}).get("delta", 0)
+        if sharpe_change > 0.1:
+            recommendations.append("Efficiency improved: Better risk-adjusted returns")
+        elif sharpe_change < -0.1:
+            recommendations.append("Efficiency decreased: Worse risk-adjusted returns")
+
+        div_change = impact.get("diversification", {}).get("delta", 0)
+        if div_change > 0.05:
+            recommendations.append("Diversification improved")
+        elif div_change < -0.05:
+            recommendations.append("Concentration increased - consider diversifying")
+
+        crash_improvement = stress.get("market_crash", {}).get("improvement", 0)
+        if crash_improvement > 0:
+            recommendations.append(
+                f"Crash resilience improved: {crash_improvement:.0f} less loss in market crash"
+            )
+
+        if not recommendations:
+            recommendations.append("Changes have minimal impact on portfolio characteristics")
+
+        return recommendations
+
+    def _assess_changes(self, impact: Dict[str, Dict[str, Any]]) -> str:
+        """Overall assessment of the proposed changes.
+
+        Args:
+            impact: Impact metrics
+
+        Returns:
+            Assessment string
+        """
+        positive_signals = 0
+        negative_signals = 0
+
+        if impact.get("var_95", {}).get("delta", 0) < 0:
+            positive_signals += 1
+        else:
+            negative_signals += 1
+
+        if impact.get("expected_return", {}).get("delta", 0) > 0:
+            positive_signals += 1
+        else:
+            negative_signals += 1
+
+        if impact.get("sharpe_ratio", {}).get("delta", 0) > 0:
+            positive_signals += 1
+        else:
+            negative_signals += 1
+
+        if impact.get("diversification", {}).get("delta", 0) > 0:
+            positive_signals += 1
+        else:
+            negative_signals += 1
+
+        if positive_signals >= 3:
+            return "RECOMMENDED: Changes improve portfolio characteristics"
+        elif negative_signals >= 3:
+            return "CAUTION: Changes may degrade portfolio performance"
+        else:
+            return "NEUTRAL: Mixed impact - review individual metrics"

backend/agents/workflow_router.py

@@ -10,6 +10,7 @@ from typing import Optional, Dict, Any, List
 from backend.agents.workflow import PortfolioAnalysisWorkflow
 from backend.agents.react_agent import PortfolioBuilderAgent
 from backend.agents.council import AdvisoryCouncil
+from backend.agents.rehearsal import PortfolioRehearsalEngine
 from backend.agents.personas import PersonaType
 from backend.models.agent_state import AgentState
 
@@ -112,7 +113,10 @@ class WorkflowRouter:
             )
 
         elif task == TaskType.TEST:
-            raise ValueError("Test Changes workflow not yet implemented")
+            raise ValueError(
+                "Test Changes requires different parameters. "
+                "Use route_test() method instead."
+            )
 
         else:
             raise ValueError(f"Unknown task type: {task}")
@@ -199,6 +203,29 @@ class WorkflowRouter:
             "council_result": council_result
         }
 
+    async def route_test(
+        self,
+        current_portfolio: Dict[str, Dict[str, Any]],
+        proposed_changes: List[Dict[str, Any]],
+        portfolio_value: float = 100000.0
+    ) -> Dict[str, Any]:
+        """Route to the Test Changes workflow with rehearsal engine.
+
+        Args:
+            current_portfolio: {ticker: {weight: float, shares: int, value: float}}
+            proposed_changes: [{action: buy/sell, ticker: str, amount: float}]
+            portfolio_value: Total portfolio value for calculations
+
+        Returns:
+            Rehearsal result with comparison metrics and recommendations
+        """
+        engine = PortfolioRehearsalEngine(self.mcp_router)
+        return await engine.rehearse_changes(
+            current_portfolio,
+            proposed_changes,
+            portfolio_value
+        )
+
     def get_available_tasks(self) -> list[Dict[str, Any]]:
         """Get list of available tasks with their status.
 
@@ -235,7 +262,7 @@ class WorkflowRouter:
                 "title": "Test Changes",
                 "description": "Preview impact before making portfolio changes",
                 "icon": "flask",
-                "enabled": False,
+                "enabled": True,
                 "task_type": TaskType.TEST,
             },
         ]

tests/test_rehearsal.py

@@ -0,0 +1,281 @@
+"""Tests for the PortfolioRehearsalEngine."""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+from decimal import Decimal
+
+from backend.agents.rehearsal import PortfolioRehearsalEngine
+
+
+class TestPortfolioRehearsalEngine:
+    """Tests for the PortfolioRehearsalEngine class."""
+
+    @pytest.fixture
+    def mock_mcp_router(self):
+        """Create a mock MCP router."""
+        router = MagicMock()
+        router.call_yahoo_finance_mcp = AsyncMock(return_value={
+            "close_prices": [100.0, 102.0, 101.0, 103.0, 105.0]
+        })
+        router.call_risk_analyzer_mcp = AsyncMock(return_value={
+            "var_percentage": 0.05,
+            "cvar_percentage": 0.07,
+            "portfolio_volatility": 0.15,
+            "sharpe_ratio": 1.2,
+            "max_drawdown": 0.10
+        })
+        return router
+
+    @pytest.fixture
+    def engine(self, mock_mcp_router):
+        """Create a PortfolioRehearsalEngine instance."""
+        return PortfolioRehearsalEngine(mock_mcp_router)
+
+    def test_engine_initialization(self, engine, mock_mcp_router):
+        """Test engine initialisation."""
+        assert engine.mcp_router == mock_mcp_router
+
+    def test_apply_changes_sell(self, engine):
+        """Test applying sell changes to portfolio."""
+        portfolio = {
+            "AAPL": {"weight": 50},
+            "TSLA": {"weight": 30},
+            "BND": {"weight": 20}
+        }
+        changes = [{"action": "sell", "ticker": "TSLA", "amount": 15}]
+
+        result = engine._apply_changes(portfolio, changes)
+
+        assert "AAPL" in result
+        assert "TSLA" in result
+        assert "BND" in result
+        total = sum(h["weight"] for h in result.values())
+        assert abs(total - 100) < 0.01
+
+    def test_apply_changes_buy(self, engine):
+        """Test applying buy changes to portfolio."""
+        portfolio = {
+            "AAPL": {"weight": 50},
+            "BND": {"weight": 50}
+        }
+        changes = [{"action": "buy", "ticker": "TSLA", "amount": 20}]
+
+        result = engine._apply_changes(portfolio, changes)
+
+        assert "AAPL" in result
+        assert "BND" in result
+        assert "TSLA" in result
+        total = sum(h["weight"] for h in result.values())
+        assert abs(total - 100) < 0.01
+
+    def test_apply_changes_sell_all(self, engine):
+        """Test selling entire position removes ticker from portfolio."""
+        portfolio = {
+            "AAPL": {"weight": 50},
+            "TSLA": {"weight": 50}
+        }
+        changes = [{"action": "sell", "ticker": "TSLA", "amount": 50}]
+
+        result = engine._apply_changes(portfolio, changes)
+
+        assert "AAPL" in result
+        assert "TSLA" not in result
+        assert result["AAPL"]["weight"] == 100
+
+    def test_calculate_impact(self, engine):
+        """Test impact calculation between portfolios."""
+        current = {
+            "expected_return": 10.0,
+            "var_95": 5.0,
+            "sharpe_ratio": 1.0,
+            "num_holdings": 3
+        }
+        simulated = {
+            "expected_return": 12.0,
+            "var_95": 4.0,
+            "sharpe_ratio": 1.2,
+            "num_holdings": 4
+        }
+
+        impact = engine._calculate_impact(current, simulated)
+
+        assert "expected_return" in impact
+        assert impact["expected_return"]["current"] == 10.0
+        assert impact["expected_return"]["simulated"] == 12.0
+        assert impact["expected_return"]["delta"] == 2.0
+        assert impact["expected_return"]["pct_change"] == 20.0
+
+        assert impact["var_95"]["delta"] == -1.0
+
+    def test_generate_recommendations_risk_reduction(self, engine):
+        """Test recommendations for risk reduction."""
+        impact = {
+            "var_95": {"pct_change": -15},
+            "expected_return": {"pct_change": 3},
+            "sharpe_ratio": {"delta": 0.05},
+            "diversification": {"delta": 0.02}
+        }
+        stress = {}
+
+        recs = engine._generate_recommendations(impact, stress)
+
+        assert any("Risk reduction" in rec for rec in recs)
+
+    def test_generate_recommendations_risk_increase(self, engine):
+        """Test recommendations for risk increase."""
+        impact = {
+            "var_95": {"pct_change": 15},
+            "expected_return": {"pct_change": 3},
+            "sharpe_ratio": {"delta": 0.05},
+            "diversification": {"delta": 0.02}
+        }
+        stress = {}
+
+        recs = engine._generate_recommendations(impact, stress)
+
+        assert any("Risk increase" in rec for rec in recs)
+
+    def test_assess_changes_recommended(self, engine):
+        """Test assessment returns RECOMMENDED for positive changes."""
+        impact = {
+            "var_95": {"delta": -0.01},
+            "expected_return": {"delta": 0.02},
+            "sharpe_ratio": {"delta": 0.1},
+            "diversification": {"delta": 0.05}
+        }
+
+        assessment = engine._assess_changes(impact)
+
+        assert "RECOMMENDED" in assessment
+
+    def test_assess_changes_caution(self, engine):
+        """Test assessment returns CAUTION for negative changes."""
+        impact = {
+            "var_95": {"delta": 0.02},
+            "expected_return": {"delta": -0.01},
+            "sharpe_ratio": {"delta": -0.1},
+            "diversification": {"delta": -0.05}
+        }
+
+        assessment = engine._assess_changes(impact)
+
+        assert "CAUTION" in assessment
+
+    def test_assess_changes_neutral(self, engine):
+        """Test assessment returns NEUTRAL for mixed changes."""
+        impact = {
+            "var_95": {"delta": -0.01},
+            "expected_return": {"delta": -0.01},
+            "sharpe_ratio": {"delta": 0.1},
+            "diversification": {"delta": -0.05}
+        }
+
+        assessment = engine._assess_changes(impact)
+
+        assert "NEUTRAL" in assessment
+
+    def test_estimate_beta(self, engine):
+        """Test beta estimation for different ticker types."""
+        assert engine._estimate_beta("TSLA", {}) == 1.5
+        assert engine._estimate_beta("BND", {}) == 0.5
+        assert engine._estimate_beta("AAPL", {}) == 1.0
+
+    def test_calculate_expected_return(self, engine):
+        """Test expected return calculation."""
+        portfolio = {
+            "AAPL": {"weight": 60},
+            "BND": {"weight": 40}
+        }
+        historical_data = {
+            "AAPL": {"close_prices": [100.0, 110.0]},
+            "BND": {"close_prices": [50.0, 51.0]}
+        }
+
+        result = engine._calculate_expected_return(portfolio, historical_data)
+
+        aapl_return = 10.0 * 0.6
+        bnd_return = 2.0 * 0.4
+        expected = aapl_return + bnd_return
+        assert abs(result - expected) < 0.01
+
+    @pytest.mark.asyncio
+    async def test_rehearse_changes_structure(self, engine, mock_mcp_router):
+        """Test that rehearse_changes returns expected structure."""
+        current_portfolio = {
+            "AAPL": {"weight": 50},
+            "TSLA": {"weight": 30},
+            "BND": {"weight": 20}
+        }
+        proposed_changes = [
+            {"action": "sell", "ticker": "TSLA", "amount": 10},
+            {"action": "buy", "ticker": "VTI", "amount": 10}
+        ]
+
+        result = await engine.rehearse_changes(
+            current_portfolio,
+            proposed_changes,
+            portfolio_value=100000.0
+        )
+
+        assert "current" in result
+        assert "simulated" in result
+        assert "impact" in result
+        assert "stress_comparison" in result
+        assert "recommendations" in result
+        assert "overall_assessment" in result
+
+        assert "portfolio" in result["current"]
+        assert "metrics" in result["current"]
+        assert "portfolio" in result["simulated"]
+        assert "metrics" in result["simulated"]
+
+    @pytest.mark.asyncio
+    async def test_rehearse_changes_empty_portfolio(self, engine, mock_mcp_router):
+        """Test rehearsing changes with empty portfolio."""
+        current_portfolio = {}
+        proposed_changes = [
+            {"action": "buy", "ticker": "VTI", "amount": 100}
+        ]
+
+        result = await engine.rehearse_changes(
+            current_portfolio,
+            proposed_changes,
+            portfolio_value=100000.0
+        )
+
+        assert "current" in result
+        assert "simulated" in result
+        assert result["simulated"]["portfolio"]["VTI"]["weight"] == 100
+
+    @pytest.mark.asyncio
+    async def test_analyse_portfolio_empty(self, engine):
+        """Test analysing empty portfolio returns zero metrics."""
+        result = await engine._analyse_portfolio({}, {}, 100000.0)
+
+        assert result["expected_return"] == 0.0
+        assert result["var_95"] == 0.0
+        assert result["num_holdings"] == 0
+
+    @pytest.mark.asyncio
+    async def test_compare_stress_tests(self, engine, mock_mcp_router):
+        """Test stress test comparison."""
+        current_portfolio = {"AAPL": {"weight": 100}}
+        simulated_portfolio = {"BND": {"weight": 100}}
+        historical_data = {}
+
+        result = await engine._compare_stress_tests(
+            current_portfolio,
+            simulated_portfolio,
+            historical_data,
+            100000.0
+        )
+
+        assert "market_crash" in result
+        assert "correction" in result
+        assert "mild_decline" in result
+
+        for scenario in result.values():
+            assert "shock" in scenario
+            assert "current_loss" in scenario
+            assert "simulated_loss" in scenario
+            assert "improvement" in scenario