[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7BWNGAKFD8KPEA9D1JBZ4VR":3,"skill-same:01M7BWNGAKFD8KPEA9D1JBZ4VR":47},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":6,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M7BWNGAKFD8KPEA9D1JBZ4VR","risk-metrics-calculation",null,"Calculate portfolio risk metrics including VaR, CVaR, Sharpe, Sortino, and drawdown analysis. Use when measuring portfolio risk, implementing risk limits, or building risk monitoring systems.","YYC-Cube\u002FYYC3-Knowledge-Base","YYC-Cube","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F235006543?v=4","01M79J2PH4SWD2X0825X6PN748","yyc3","01M79J2PHVK3F6ZBYT8K2SCZCW",1,"MIT","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-plugins-claude\u002Fquantitative-trading\u002Fskills\u002Frisk-metrics-calculation\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: risk-metrics-calculation\ndescription: Calculate portfolio risk metrics including VaR, CVaR, Sharpe, Sortino, and drawdown analysis. Use when measuring portfolio risk, implementing risk limits, or building risk monitoring systems.\n---\n\n# Risk Metrics Calculation\n\nComprehensive risk measurement toolkit for portfolio management, including Value at Risk, Expected Shortfall, and drawdown analysis.\n\n## When to Use This Skill\n\n- Measuring portfolio risk\n- Implementing risk limits\n- Building risk dashboards\n- Calculating risk-adjusted returns\n- Setting position sizes\n- Regulatory reporting\n\n## Core Concepts\n\n### 1. Risk Metric Categories\n\n| Category          | Metrics         | Use Case             |\n| ----------------- | --------------- | -------------------- |\n| **Volatility**    | Std Dev, Beta   | General risk         |\n| **Tail Risk**     | VaR, CVaR       | Extreme losses       |\n| **Drawdown**      | Max DD, Calmar  | Capital preservation |\n| **Risk-Adjusted** | Sharpe, Sortino | Performance          |\n\n### 2. Time Horizons\n\n```\nIntraday:   Minute\u002Fhourly VaR for day traders\nDaily:      Standard risk reporting\nWeekly:     Rebalancing decisions\nMonthly:    Performance attribution\nAnnual:     Strategic allocation\n```\n\n## Implementation\n\n### Pattern 1: Core Risk Metrics\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom scipy import stats\nfrom typing import Dict, Optional, Tuple\n\nclass RiskMetrics:\n    \"\"\"Core risk metric calculations.\"\"\"\n\n    def __init__(self, returns: pd.Series, rf_rate: float = 0.02):\n        \"\"\"\n        Args:\n            returns: Series of periodic returns\n            rf_rate: Annual risk-free rate\n        \"\"\"\n        self.returns = returns\n        self.rf_rate = rf_rate\n        self.ann_factor = 252  # Trading days per year\n\n    # Volatility Metrics\n    def volatility(self, annualized: bool = True) -> float:\n        \"\"\"Standard deviation of returns.\"\"\"\n        vol = self.returns.std()\n        if annualized:\n            vol *= np.sqrt(self.ann_factor)\n        return vol\n\n    def downside_deviation(self, threshold: float = 0, annualized: bool = True) -> float:\n        \"\"\"Standard deviation of returns below threshold.\"\"\"\n        downside = self.returns[self.returns \u003C threshold]\n        if len(downside) == 0:\n            return 0.0\n        dd = downside.std()\n        if annualized:\n            dd *= np.sqrt(self.ann_factor)\n        return dd\n\n    def beta(self, market_returns: pd.Series) -> float:\n        \"\"\"Beta relative to market.\"\"\"\n        aligned = pd.concat([self.returns, market_returns], axis=1).dropna()\n        if len(aligned) \u003C 2:\n            return np.nan\n        cov = np.cov(aligned.iloc[:, 0], aligned.iloc[:, 1])\n        return cov[0, 1] \u002F cov[1, 1] if cov[1, 1] != 0 else 0\n\n    # Value at Risk\n    def var_historical(self, confidence: float = 0.95) -> float:\n        \"\"\"Historical VaR at confidence level.\"\"\"\n        return -np.percentile(self.returns, (1 - confidence) * 100)\n\n    def var_parametric(self, confidence: float = 0.95) -> float:\n        \"\"\"Parametric VaR assuming normal distribution.\"\"\"\n        z_score = stats.norm.ppf(confidence)\n        return self.returns.mean() - z_score * self.returns.std()\n\n    def var_cornish_fisher(self, confidence: float = 0.95) -> float:\n        \"\"\"VaR with Cornish-Fisher expansion for non-normality.\"\"\"\n        z = stats.norm.ppf(confidence)\n        s = stats.skew(self.returns)  # Skewness\n        k = stats.kurtosis(self.returns)  # Excess kurtosis\n\n        # Cornish-Fisher expansion\n        z_cf = (z + (z**2 - 1) * s \u002F 6 +\n                (z**3 - 3*z) * k \u002F 24 -\n                (2*z**3 - 5*z) * s**2 \u002F 36)\n\n        return -(self.returns.mean() + z_cf * self.returns.std())\n\n    # Conditional VaR (Expected Shortfall)\n    def cvar(self, confidence: float = 0.95) -> float:\n        \"\"\"Expected Shortfall \u002F CVaR \u002F Average VaR.\"\"\"\n        var = self.var_historical(confidence)\n        return -self.returns[self.returns \u003C= -var].mean()\n\n    # Drawdown Analysis\n    def drawdowns(self) -> pd.Series:\n        \"\"\"Calculate drawdown series.\"\"\"\n        cumulative = (1 + self.returns).cumprod()\n        running_max = cumulative.cummax()\n        return (cumulative - running_max) \u002F running_max\n\n    def max_drawdown(self) -> float:\n        \"\"\"Maximum drawdown.\"\"\"\n        return self.drawdowns().min()\n\n    def avg_drawdown(self) -> float:\n        \"\"\"Average drawdown.\"\"\"\n        dd = self.drawdowns()\n        return dd[dd \u003C 0].mean() if (dd \u003C 0).any() else 0\n\n    def drawdown_duration(self) -> Dict[str, int]:\n        \"\"\"Drawdown duration statistics.\"\"\"\n        dd = self.drawdowns()\n        in_drawdown = dd \u003C 0\n\n        # Find drawdown periods\n        drawdown_starts = in_drawdown & ~in_drawdown.shift(1).fillna(False)\n        drawdown_ends = ~in_drawdown & in_drawdown.shift(1).fillna(False)\n\n        durations = []\n        current_duration = 0\n\n        for i in range(len(dd)):\n            if in_drawdown.iloc[i]:\n                current_duration += 1\n            elif current_duration > 0:\n                durations.append(current_duration)\n                current_duration = 0\n\n        if current_duration > 0:\n            durations.append(current_duration)\n\n        return {\n            \"max_duration\": max(durations) if durations else 0,\n            \"avg_duration\": np.mean(durations) if durations else 0,\n            \"current_duration\": current_duration\n        }\n\n    # Risk-Adjusted Returns\n    def sharpe_ratio(self) -> float:\n        \"\"\"Annualized Sharpe ratio.\"\"\"\n        excess_return = self.returns.mean() * self.ann_factor - self.rf_rate\n        vol = self.volatility(annualized=True)\n        return excess_return \u002F vol if vol > 0 else 0\n\n    def sortino_ratio(self) -> float:\n        \"\"\"Sortino ratio using downside deviation.\"\"\"\n        excess_return = self.returns.mean() * self.ann_factor - self.rf_rate\n        dd = self.downside_deviation(threshold=0, annualized=True)\n        return excess_return \u002F dd if dd > 0 else 0\n\n    def calmar_ratio(self) -> float:\n        \"\"\"Calmar ratio (return \u002F max drawdown).\"\"\"\n        annual_return = (1 + self.returns).prod() ** (self.ann_factor \u002F len(self.returns)) - 1\n        max_dd = abs(self.max_drawdown())\n        return annual_return \u002F max_dd if max_dd > 0 else 0\n\n    def omega_ratio(self, threshold: float = 0) -> float:\n        \"\"\"Omega ratio.\"\"\"\n        returns_above = self.returns[self.returns > threshold] - threshold\n        returns_below = threshold - self.returns[self.returns \u003C= threshold]\n\n        if returns_below.sum() == 0:\n            return np.inf\n\n        return returns_above.sum() \u002F returns_below.sum()\n\n    # Information Ratio\n    def information_ratio(self, benchmark_returns: pd.Series) -> float:\n        \"\"\"Information ratio vs benchmark.\"\"\"\n        active_returns = self.returns - benchmark_returns\n        tracking_error = active_returns.std() * np.sqrt(self.ann_factor)\n        active_return = active_returns.mean() * self.ann_factor\n        return active_return \u002F tracking_error if tracking_error > 0 else 0\n\n    # Summary\n    def summary(self) -> Dict[str, float]:\n        \"\"\"Generate comprehensive risk summary.\"\"\"\n        dd_stats = self.drawdown_duration()\n\n        return {\n            # Returns\n            \"total_return\": (1 + self.returns).prod() - 1,\n            \"annual_return\": (1 + self.returns).prod() ** (self.ann_factor \u002F len(self.returns)) - 1,\n\n            # Volatility\n            \"annual_volatility\": self.volatility(),\n            \"downside_deviation\": self.downside_deviation(),\n\n            # VaR & CVaR\n            \"var_95_historical\": self.var_historical(0.95),\n            \"var_99_historical\": self.var_historical(0.99),\n            \"cvar_95\": self.cvar(0.95),\n\n            # Drawdowns\n            \"max_drawdown\": self.max_drawdown(),\n            \"avg_drawdown\": self.avg_drawdown(),\n            \"max_drawdown_duration\": dd_stats[\"max_duration\"],\n\n            # Risk-Adjusted\n            \"sharpe_ratio\": self.sharpe_ratio(),\n            \"sortino_ratio\": self.sortino_ratio(),\n            \"calmar_ratio\": self.calmar_ratio(),\n            \"omega_ratio\": self.omega_ratio(),\n\n            # Distribution\n            \"skewness\": stats.skew(self.returns),\n            \"kurtosis\": stats.kurtosis(self.returns),\n        }\n```\n\n### Pattern 2: Portfolio Risk\n\n```python\nclass PortfolioRisk:\n    \"\"\"Portfolio-level risk calculations.\"\"\"\n\n    def __init__(\n        self,\n        returns: pd.DataFrame,\n        weights: Optional[pd.Series] = None\n    ):\n        \"\"\"\n        Args:\n            returns: DataFrame with asset returns (columns = assets)\n            weights: Portfolio weights (default: equal weight)\n        \"\"\"\n        self.returns = returns\n        self.weights = weights if weights is not None else \\\n            pd.Series(1\u002Flen(returns.columns), index=returns.columns)\n        self.ann_factor = 252\n\n    def portfolio_return(self) -> float:\n        \"\"\"Weighted portfolio return.\"\"\"\n        return (self.returns @ self.weights).mean() * self.ann_factor\n\n    def portfolio_volatility(self) -> float:\n        \"\"\"Portfolio volatility.\"\"\"\n        cov_matrix = self.returns.cov() * self.ann_factor\n        port_var = self.weights @ cov_matrix @ self.weights\n        return np.sqrt(port_var)\n\n    def marginal_risk_contribution(self) -> pd.Series:\n        \"\"\"Marginal contribution to risk by asset.\"\"\"\n        cov_matrix = self.returns.cov() * self.ann_factor\n        port_vol = self.portfolio_volatility()\n\n        # Marginal contribution\n        mrc = (cov_matrix @ self.weights) \u002F port_vol\n        return mrc\n\n    def component_risk(self) -> pd.Series:\n        \"\"\"Component contribution to total risk.\"\"\"\n        mrc = self.marginal_risk_contribution()\n        return self.weights * mrc\n\n    def risk_parity_weights(self, target_vol: float = None) -> pd.Series:\n        \"\"\"Calculate risk parity weights.\"\"\"\n        from scipy.optimize import minimize\n\n        n = len(self.returns.columns)\n        cov_matrix = self.returns.cov() * self.ann_factor\n\n        def risk_budget_objective(weights):\n            port_vol = np.sqrt(weights @ cov_matrix @ weights)\n            mrc = (cov_matrix @ weights) \u002F port_vol\n            rc = weights * mrc\n            target_rc = port_vol \u002F n  # Equal risk contribution\n            return np.sum((rc - target_rc) ** 2)\n\n        constraints = [\n            {\"type\": \"eq\", \"fun\": lambda w: np.sum(w) - 1},  # Weights sum to 1\n        ]\n        bounds = [(0.01, 1.0) for _ in range(n)]  # Min 1%, max 100%\n        x0 = np.array([1\u002Fn] * n)\n\n        result = minimize(\n            risk_budget_objective,\n            x0,\n            method=\"SLSQP\",\n            bounds=bounds,\n            constraints=constraints\n        )\n\n        return pd.Series(result.x, index=self.returns.columns)\n\n    def correlation_matrix(self) -> pd.DataFrame:\n        \"\"\"Asset correlation matrix.\"\"\"\n        return self.returns.corr()\n\n    def diversification_ratio(self) -> float:\n        \"\"\"Diversification ratio (higher = more diversified).\"\"\"\n        asset_vols = self.returns.std() * np.sqrt(self.ann_factor)\n        weighted_vol = (self.weights * asset_vols).sum()\n        port_vol = self.portfolio_volatility()\n        return weighted_vol \u002F port_vol if port_vol > 0 else 1\n\n    def tracking_error(self, benchmark_returns: pd.Series) -> float:\n        \"\"\"Tracking error vs benchmark.\"\"\"\n        port_returns = self.returns @ self.weights\n        active_returns = port_returns - benchmark_returns\n        return active_returns.std() * np.sqrt(self.ann_factor)\n\n    def conditional_correlation(\n        self,\n        threshold_percentile: float = 10\n    ) -> pd.DataFrame:\n        \"\"\"Correlation during stress periods.\"\"\"\n        port_returns = self.returns @ self.weights\n        threshold = np.percentile(port_returns, threshold_percentile)\n        stress_mask = port_returns \u003C= threshold\n        return self.returns[stress_mask].corr()\n```\n\n### Pattern 3: Rolling Risk Metrics\n\n```python\nclass RollingRiskMetrics:\n    \"\"\"Rolling window risk calculations.\"\"\"\n\n    def __init__(self, returns: pd.Series, window: int = 63):\n        \"\"\"\n        Args:\n            returns: Return series\n            window: Rolling window size (default: 63 = ~3 months)\n        \"\"\"\n        self.returns = returns\n        self.window = window\n\n    def rolling_volatility(self, annualized: bool = True) -> pd.Series:\n        \"\"\"Rolling volatility.\"\"\"\n        vol = self.returns.rolling(self.window).std()\n        if annualized:\n            vol *= np.sqrt(252)\n        return vol\n\n    def rolling_sharpe(self, rf_rate: float = 0.02) -> pd.Series:\n        \"\"\"Rolling Sharpe ratio.\"\"\"\n        rolling_return = self.returns.rolling(self.window).mean() * 252\n        rolling_vol = self.rolling_volatility()\n        return (rolling_return - rf_rate) \u002F rolling_vol\n\n    def rolling_var(self, confidence: float = 0.95) -> pd.Series:\n        \"\"\"Rolling historical VaR.\"\"\"\n        return self.returns.rolling(self.window).apply(\n            lambda x: -np.percentile(x, (1 - confidence) * 100),\n            raw=True\n        )\n\n    def rolling_max_drawdown(self) -> pd.Series:\n        \"\"\"Rolling maximum drawdown.\"\"\"\n        def max_dd(returns):\n            cumulative = (1 + returns).cumprod()\n            running_max = cumulative.cummax()\n            drawdowns = (cumulative - running_max) \u002F running_max\n            return drawdowns.min()\n\n        return self.returns.rolling(self.window).apply(max_dd, raw=False)\n\n    def rolling_beta(self, market_returns: pd.Series) -> pd.Series:\n        \"\"\"Rolling beta vs market.\"\"\"\n        def calc_beta(window_data):\n            port_ret = window_data.iloc[:, 0]\n            mkt_ret = window_data.iloc[:, 1]\n            cov = np.cov(port_ret, mkt_ret)\n            return cov[0, 1] \u002F cov[1, 1] if cov[1, 1] != 0 else 0\n\n        combined = pd.concat([self.returns, market_returns], axis=1)\n        return combined.rolling(self.window).apply(\n            lambda x: calc_beta(x.to_frame()),\n            raw=False\n        ).iloc[:, 0]\n\n    def volatility_regime(\n        self,\n        low_threshold: float = 0.10,\n        high_threshold: float = 0.20\n    ) -> pd.Series:\n        \"\"\"Classify volatility regime.\"\"\"\n        vol = self.rolling_volatility()\n\n        def classify(v):\n            if v \u003C low_threshold:\n                return \"low\"\n            elif v > high_threshold:\n                return \"high\"\n            else:\n                return \"normal\"\n\n        return vol.apply(classify)\n```\n\n### Pattern 4: Stress Testing\n\n```python\nclass StressTester:\n    \"\"\"Historical and hypothetical stress testing.\"\"\"\n\n    # Historical crisis periods\n    HISTORICAL_SCENARIOS = {\n        \"2008_financial_crisis\": (\"2008-09-01\", \"2009-03-31\"),\n        \"2020_covid_crash\": (\"2020-02-19\", \"2020-03-23\"),\n        \"2022_rate_hikes\": (\"2022-01-01\", \"2022-10-31\"),\n        \"dot_com_bust\": (\"2000-03-01\", \"2002-10-01\"),\n        \"flash_crash_2010\": (\"2010-05-06\", \"2010-05-06\"),\n    }\n\n    def __init__(self, returns: pd.Series, weights: pd.Series = None):\n        self.returns = returns\n        self.weights = weights\n\n    def historical_stress_test(\n        self,\n        scenario_name: str,\n        historical_data: pd.DataFrame\n    ) -> Dict[str, float]:\n        \"\"\"Test portfolio against historical crisis period.\"\"\"\n        if scenario_name not in self.HISTORICAL_SCENARIOS:\n            raise ValueError(f\"Unknown scenario: {scenario_name}\")\n\n        start, end = self.HISTORICAL_SCENARIOS[scenario_name]\n\n        # Get returns during crisis\n        crisis_returns = historical_data.loc[start:end]\n\n        if self.weights is not None:\n            port_returns = (crisis_returns @ self.weights)\n        else:\n            port_returns = crisis_returns\n\n        total_return = (1 + port_returns).prod() - 1\n        max_dd = self._calculate_max_dd(port_returns)\n        worst_day = port_returns.min()\n\n        return {\n            \"scenario\": scenario_name,\n            \"period\": f\"{start} to {end}\",\n            \"total_return\": total_return,\n            \"max_drawdown\": max_dd,\n            \"worst_day\": worst_day,\n            \"volatility\": port_returns.std() * np.sqrt(252)\n        }\n\n    def hypothetical_stress_test(\n        self,\n        shocks: Dict[str, float]\n    ) -> float:\n        \"\"\"\n        Test portfolio against hypothetical shocks.\n\n        Args:\n            shocks: Dict of {asset: shock_return}\n        \"\"\"\n        if self.weights is None:\n            raise ValueError(\"Weights required for hypothetical stress test\")\n\n        total_impact = 0\n        for asset, shock in shocks.items():\n            if asset in self.weights.index:\n                total_impact += self.weights[asset] * shock\n\n        return total_impact\n\n    def monte_carlo_stress(\n        self,\n        n_simulations: int = 10000,\n        horizon_days: int = 21,\n        vol_multiplier: float = 2.0\n    ) -> Dict[str, float]:\n        \"\"\"Monte Carlo stress test with elevated volatility.\"\"\"\n        mean = self.returns.mean()\n        vol = self.returns.std() * vol_multiplier\n\n        simulations = np.random.normal(\n            mean,\n            vol,\n            (n_simulations, horizon_days)\n        )\n\n        total_returns = (1 + simulations).prod(axis=1) - 1\n\n        return {\n            \"expected_loss\": -total_returns.mean(),\n            \"var_95\": -np.percentile(total_returns, 5),\n            \"var_99\": -np.percentile(total_returns, 1),\n            \"worst_case\": -total_returns.min(),\n            \"prob_10pct_loss\": (total_returns \u003C -0.10).mean()\n        }\n\n    def _calculate_max_dd(self, returns: pd.Series) -> float:\n        cumulative = (1 + returns).cumprod()\n        running_max = cumulative.cummax()\n        drawdowns = (cumulative - running_max) \u002F running_max\n        return drawdowns.min()\n```\n\n## Quick Reference\n\n```python\n# Daily usage\nmetrics = RiskMetrics(returns)\nprint(f\"Sharpe: {metrics.sharpe_ratio():.2f}\")\nprint(f\"Max DD: {metrics.max_drawdown():.2%}\")\nprint(f\"VaR 95%: {metrics.var_historical(0.95):.2%}\")\n\n# Full summary\nsummary = metrics.summary()\nfor metric, value in summary.items():\n    print(f\"{metric}: {value:.4f}\")\n```\n\n## Best Practices\n\n### Do's\n\n- **Use multiple metrics** - No single metric captures all risk\n- **Consider tail risk** - VaR isn't enough, use CVaR\n- **Rolling analysis** - Risk changes over time\n- **Stress test** - Historical and hypothetical\n- **Document assumptions** - Distribution, lookback, etc.\n\n### Don'ts\n\n- **Don't rely on VaR alone** - Underestimates tail risk\n- **Don't assume normality** - Returns are fat-tailed\n- **Don't ignore correlation** - Increases in stress\n- **Don't use short lookbacks** - Miss regime changes\n- **Don't forget transaction costs** - Affects realized risk\n","# Risk Metrics Calculation\n\nComprehensive risk measurement toolkit for portfolio management, including Value at Risk, Expected Shortfall, and drawdown analysis.\n\n## When to Use This Skill\n\n- Measuring portfolio risk\n- Implementing risk limits\n- Building risk dashboards\n- Calculating risk-adjusted returns\n- Setting position sizes\n- Regulatory reporting\n\n## Core Concepts\n\n### 1. Risk Metric Categories\n\n| Category          | Metrics         | Use Case             |\n| ----------------- | --------------- | -------------------- |\n| **Volatility**    | Std Dev, Beta   | General risk         |\n| **Tail Risk**     | VaR, CVaR       | Extreme losses       |\n| **Drawdown**      | Max DD, Calmar  | Capital preservation |\n| **Risk-Adjusted** | Sharpe, Sortino | Performance          |\n\n### 2. Time Horizons\n\n```\nIntraday:   Minute\u002Fhourly VaR for day traders\nDaily:      Standard risk reporting\nWeekly:     Rebalancing decisions\nMonthly:    Performance attribution\nAnnual:     Strategic allocation\n```\n\n## Implementation\n\n### Pattern 1: Core Risk Metrics\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom scipy import stats\nfrom typing import Dict, Optional, Tuple\n\nclass RiskMetrics:\n    \"\"\"Core risk metric calculations.\"\"\"\n\n    def __init__(self, returns: pd.Series, rf_rate: float = 0.02):\n        \"\"\"\n        Args:\n            returns: Series of periodic returns\n            rf_rate: Annual risk-free rate\n        \"\"\"\n        self.returns = returns\n        self.rf_rate = rf_rate\n        self.ann_factor = 252  # Trading days per year\n\n    # Volatility Metrics\n    def volatility(self, annualized: bool = True) -> float:\n        \"\"\"Standard deviation of returns.\"\"\"\n        vol = self.returns.std()\n        if annualized:\n            vol *= np.sqrt(self.ann_factor)\n        return vol\n\n    def downside_deviation(self, threshold: float = 0, annualized: bool = True) -> float:\n        \"\"\"Standard deviation of returns below threshold.\"\"\"\n        downside = self.returns[self.returns \u003C threshold]\n        if len(downside) == 0:\n            return 0.0\n        dd = downside.std()\n        if annualized:\n            dd *= np.sqrt(self.ann_factor)\n        return dd\n\n    def beta(self, market_returns: pd.Series) -> float:\n        \"\"\"Beta relative to market.\"\"\"\n        aligned = pd.concat([self.returns, market_returns], axis=1).dropna()\n        if len(aligned) \u003C 2:\n            return np.nan\n        cov = np.cov(aligned.iloc[:, 0], aligned.iloc[:, 1])\n        return cov[0, 1] \u002F cov[1, 1] if cov[1, 1] != 0 else 0\n\n    # Value at Risk\n    def var_historical(self, confidence: float = 0.95) -> float:\n        \"\"\"Historical VaR at confidence level.\"\"\"\n        return -np.percentile(self.returns, (1 - confidence) * 100)\n\n    def var_parametric(self, confidence: float = 0.95) -> float:\n        \"\"\"Parametric VaR assuming normal distribution.\"\"\"\n        z_score = stats.norm.ppf(confidence)\n        return self.returns.mean() - z_score * self.returns.std()\n\n    def var_cornish_fisher(self, confidence: float = 0.95) -> float:\n        \"\"\"VaR with Cornish-Fisher expansion for non-normality.\"\"\"\n        z = stats.norm.ppf(confidence)\n        s = stats.skew(self.returns)  # Skewness\n        k = stats.kurtosis(self.returns)  # Excess kurtosis\n\n        # Cornish-Fisher expansion\n        z_cf = (z + (z**2 - 1) * s \u002F 6 +\n                (z**3 - 3*z) * k \u002F 24 -\n                (2*z**3 - 5*z) * s**2 \u002F 36)\n\n        return -(self.returns.mean() + z_cf * self.returns.std())\n\n    # Conditional VaR (Expected Shortfall)\n    def cvar(self, confidence: float = 0.95) -> float:\n        \"\"\"Expected Shortfall \u002F CVaR \u002F Average VaR.\"\"\"\n        var = self.var_historical(confidence)\n        return -self.returns[self.returns \u003C= -var].mean()\n\n    # Drawdown Analysis\n    def drawdowns(self) -> pd.Series:\n        \"\"\"Calculate drawdown series.\"\"\"\n        cumulative = (1 + self.returns).cumprod()\n        running_max = cumulative.cummax()\n        return (cumulative - running_max) \u002F running_max\n\n    def max_drawdown(self) -> float:\n        \"\"\"Maximum drawdown.\"\"\"\n        return self.drawdowns().min()\n\n    def avg_drawdown(self) -> float:\n        \"\"\"Average drawdown.\"\"\"\n        dd = self.drawdowns()\n        return dd[dd \u003C 0].mean() if (dd \u003C 0).any() else 0\n\n    def drawdown_duration(self) -> Dict[str, int]:\n        \"\"\"Drawdown duration statistics.\"\"\"\n        dd = self.drawdowns()\n        in_drawdown = dd \u003C 0\n\n        # Find drawdown periods\n        drawdown_starts = in_drawdown & ~in_drawdown.shift(1).fillna(False)\n        drawdown_ends = ~in_drawdown & in_drawdown.shift(1).fillna(False)\n\n        durations = []\n        current_duration = 0\n\n        for i in range(len(dd)):\n            if in_drawdown.iloc[i]:\n                current_duration += 1\n            elif current_duration > 0:\n                durations.append(current_duration)\n                current_duration = 0\n\n        if current_duration > 0:\n            durations.append(current_duration)\n\n        return {\n            \"max_duration\": max(durations) if durations else 0,\n            \"avg_duration\": np.mean(durations) if durations else 0,\n            \"current_duration\": current_duration\n        }\n\n    # Risk-Adjusted Returns\n    def sharpe_ratio(self) -> float:\n        \"\"\"Annualized Sharpe ratio.\"\"\"\n        excess_return = self.returns.mean() * self.ann_factor - self.rf_rate\n        vol = self.volatility(annualized=True)\n        return excess_return \u002F vol if vol > 0 else 0\n\n    def sortino_ratio(self) -> float:\n        \"\"\"Sortino ratio using downside deviation.\"\"\"\n        excess_return = self.returns.mean() * self.ann_factor - self.rf_rate\n        dd = self.downside_deviation(threshold=0, annualized=True)\n        return excess_return \u002F dd if dd > 0 else 0\n\n    def calmar_ratio(self) -> float:\n        \"\"\"Calmar ratio (return \u002F max drawdown).\"\"\"\n        annual_return = (1 + self.returns).prod() ** (self.ann_factor \u002F len(self.returns)) - 1\n        max_dd = abs(self.max_drawdown())\n        return annual_return \u002F max_dd if max_dd > 0 else 0\n\n    def omega_ratio(self, threshold: float = 0) -> float:\n        \"\"\"Omega ratio.\"\"\"\n        returns_above = self.returns[self.returns > threshold] - threshold\n        returns_below = threshold - self.returns[self.returns \u003C= threshold]\n\n        if returns_below.sum() == 0:\n            return np.inf\n\n        return returns_above.sum() \u002F returns_below.sum()\n\n    # Information Ratio\n    def information_ratio(self, benchmark_returns: pd.Series) -> float:\n        \"\"\"Information ratio vs benchmark.\"\"\"\n        active_returns = self.returns - benchmark_returns\n        tracking_error = active_returns.std() * np.sqrt(self.ann_factor)\n        active_return = active_returns.mean() * self.ann_factor\n        return active_return \u002F tracking_error if tracking_error > 0 else 0\n\n    # Summary\n    def summary(self) -> Dict[str, float]:\n        \"\"\"Generate comprehensive risk summary.\"\"\"\n        dd_stats = self.drawdown_duration()\n\n        return {\n            # Returns\n            \"total_return\": (1 + self.returns).prod() - 1,\n            \"annual_return\": (1 + self.returns).prod() ** (self.ann_factor \u002F len(self.returns)) - 1,\n\n            # Volatility\n            \"annual_volatility\": self.volatility(),\n            \"downside_deviation\": self.downside_deviation(),\n\n            # VaR & CVaR\n            \"var_95_historical\": self.var_historical(0.95),\n            \"var_99_historical\": self.var_historical(0.99),\n            \"cvar_95\": self.cvar(0.95),\n\n            # Drawdowns\n            \"max_drawdown\": self.max_drawdown(),\n            \"avg_drawdown\": self.avg_drawdown(),\n            \"max_drawdown_duration\": dd_stats[\"max_duration\"],\n\n            # Risk-Adjusted\n            \"sharpe_ratio\": self.sharpe_ratio(),\n            \"sortino_ratio\": self.sortino_ratio(),\n            \"calmar_ratio\": self.calmar_ratio(),\n            \"omega_ratio\": self.omega_ratio(),\n\n            # Distribution\n            \"skewness\": stats.skew(self.returns),\n            \"kurtosis\": stats.kurtosis(self.returns),\n        }\n```\n\n### Pattern 2: Portfolio Risk\n\n```python\nclass PortfolioRisk:\n    \"\"\"Portfolio-level risk calculations.\"\"\"\n\n    def __init__(\n        self,\n        returns: pd.DataFrame,\n        weights: Optional[pd.Series] = None\n    ):\n        \"\"\"\n        Args:\n            returns: DataFrame with asset returns (columns = assets)\n            weights: Portfolio weights (default: equal weight)\n        \"\"\"\n        self.returns = returns\n        self.weights = weights if weights is not None else \\\n            pd.Series(1\u002Flen(returns.columns), index=returns.columns)\n        self.ann_factor = 252\n\n    def portfolio_return(self) -> float:\n        \"\"\"Weighted portfolio return.\"\"\"\n        return (self.returns @ self.weights).mean() * self.ann_factor\n\n    def portfolio_volatility(self) -> float:\n        \"\"\"Portfolio volatility.\"\"\"\n        cov_matrix = self.returns.cov() * self.ann_factor\n        port_var = self.weights @ cov_matrix @ self.weights\n        return np.sqrt(port_var)\n\n    def marginal_risk_contribution(self) -> pd.Series:\n        \"\"\"Marginal contribution to risk by asset.\"\"\"\n        cov_matrix = self.returns.cov() * self.ann_factor\n        port_vol = self.portfolio_volatility()\n\n        # Marginal contribution\n        mrc = (cov_matrix @ self.weights) \u002F port_vol\n        return mrc\n\n    def component_risk(self) -> pd.Series:\n        \"\"\"Component contribution to total risk.\"\"\"\n        mrc = self.marginal_risk_contribution()\n        return self.weights * mrc\n\n    def risk_parity_weights(self, target_vol: float = None) -> pd.Series:\n        \"\"\"Calculate risk parity weights.\"\"\"\n        from scipy.optimize import minimize\n\n        n = len(self.returns.columns)\n        cov_matrix = self.returns.cov() * self.ann_factor\n\n        def risk_budget_objective(weights):\n            port_vol = np.sqrt(weights @ cov_matrix @ weights)\n            mrc = (cov_matrix @ weights) \u002F port_vol\n            rc = weights * mrc\n            target_rc = port_vol \u002F n  # Equal risk contribution\n            return np.sum((rc - target_rc) ** 2)\n\n        constraints = [\n            {\"type\": \"eq\", \"fun\": lambda w: np.sum(w) - 1},  # Weights sum to 1\n        ]\n        bounds = [(0.01, 1.0) for _ in range(n)]  # Min 1%, max 100%\n        x0 = np.array([1\u002Fn] * n)\n\n        result = minimize(\n            risk_budget_objective,\n            x0,\n            method=\"SLSQP\",\n            bounds=bounds,\n            constraints=constraints\n        )\n\n        return pd.Series(result.x, index=self.returns.columns)\n\n    def correlation_matrix(self) -> pd.DataFrame:\n        \"\"\"Asset correlation matrix.\"\"\"\n        return self.returns.corr()\n\n    def diversification_ratio(self) -> float:\n        \"\"\"Diversification ratio (higher = more diversified).\"\"\"\n        asset_vols = self.returns.std() * np.sqrt(self.ann_factor)\n        weighted_vol = (self.weights * asset_vols).sum()\n        port_vol = self.portfolio_volatility()\n        return weighted_vol \u002F port_vol if port_vol > 0 else 1\n\n    def tracking_error(self, benchmark_returns: pd.Series) -> float:\n        \"\"\"Tracking error vs benchmark.\"\"\"\n        port_returns = self.returns @ self.weights\n        active_returns = port_returns - benchmark_returns\n        return active_returns.std() * np.sqrt(self.ann_factor)\n\n    def conditional_correlation(\n        self,\n        threshold_percentile: float = 10\n    ) -> pd.DataFrame:\n        \"\"\"Correlation during stress periods.\"\"\"\n        port_returns = self.returns @ self.weights\n        threshold = np.percentile(port_returns, threshold_percentile)\n        stress_mask = port_returns \u003C= threshold\n        return self.returns[stress_mask].corr()\n```\n\n### Pattern 3: Rolling Risk Metrics\n\n```python\nclass RollingRiskMetrics:\n    \"\"\"Rolling window risk calculations.\"\"\"\n\n    def __init__(self, returns: pd.Series, window: int = 63):\n        \"\"\"\n        Args:\n            returns: Return series\n            window: Rolling window size (default: 63 = ~3 months)\n        \"\"\"\n        self.returns = returns\n        self.window = window\n\n    def rolling_volatility(self, annualized: bool = True) -> pd.Series:\n        \"\"\"Rolling volatility.\"\"\"\n        vol = self.returns.rolling(self.window).std()\n        if annualized:\n            vol *= np.sqrt(252)\n        return vol\n\n    def rolling_sharpe(self, rf_rate: float = 0.02) -> pd.Series:\n        \"\"\"Rolling Sharpe ratio.\"\"\"\n        rolling_return = self.returns.rolling(self.window).mean() * 252\n        rolling_vol = self.rolling_volatility()\n        return (rolling_return - rf_rate) \u002F rolling_vol\n\n    def rolling_var(self, confidence: float = 0.95) -> pd.Series:\n        \"\"\"Rolling historical VaR.\"\"\"\n        return self.returns.rolling(self.window).apply(\n            lambda x: -np.percentile(x, (1 - confidence) * 100),\n            raw=True\n        )\n\n    def rolling_max_drawdown(self) -> pd.Series:\n        \"\"\"Rolling maximum drawdown.\"\"\"\n        def max_dd(returns):\n            cumulative = (1 + returns).cumprod()\n            running_max = cumulative.cummax()\n            drawdowns = (cumulative - running_max) \u002F running_max\n            return drawdowns.min()\n\n        return self.returns.rolling(self.window).apply(max_dd, raw=False)\n\n    def rolling_beta(self, market_returns: pd.Series) -> pd.Series:\n        \"\"\"Rolling beta vs market.\"\"\"\n        def calc_beta(window_data):\n            port_ret = window_data.iloc[:, 0]\n            mkt_ret = window_data.iloc[:, 1]\n            cov = np.cov(port_ret, mkt_ret)\n            return cov[0, 1] \u002F cov[1, 1] if cov[1, 1] != 0 else 0\n\n        combined = pd.concat([self.returns, market_returns], axis=1)\n        return combined.rolling(self.window).apply(\n            lambda x: calc_beta(x.to_frame()),\n            raw=False\n        ).iloc[:, 0]\n\n    def volatility_regime(\n        self,\n        low_threshold: float = 0.10,\n        high_threshold: float = 0.20\n    ) -> pd.Series:\n        \"\"\"Classify volatility regime.\"\"\"\n        vol = self.rolling_volatility()\n\n        def classify(v):\n            if v \u003C low_threshold:\n                return \"low\"\n            elif v > high_threshold:\n                return \"high\"\n            else:\n                return \"normal\"\n\n        return vol.apply(classify)\n```\n\n### Pattern 4: Stress Testing\n\n```python\nclass StressTester:\n    \"\"\"Historical and hypothetical stress testing.\"\"\"\n\n    # Historical crisis periods\n    HISTORICAL_SCENARIOS = {\n        \"2008_financial_crisis\": (\"2008-09-01\", \"2009-03-31\"),\n        \"2020_covid_crash\": (\"2020-02-19\", \"2020-03-23\"),\n        \"2022_rate_hikes\": (\"2022-01-01\", \"2022-10-31\"),\n        \"dot_com_bust\": (\"2000-03-01\", \"2002-10-01\"),\n        \"flash_crash_2010\": (\"2010-05-06\", \"2010-05-06\"),\n    }\n\n    def __init__(self, returns: pd.Series, weights: pd.Series = None):\n        self.returns = returns\n        self.weights = weights\n\n    def historical_stress_test(\n        self,\n        scenario_name: str,\n        historical_data: pd.DataFrame\n    ) -> Dict[str, float]:\n        \"\"\"Test portfolio against historical crisis period.\"\"\"\n        if scenario_name not in self.HISTORICAL_SCENARIOS:\n            raise ValueError(f\"Unknown scenario: {scenario_name}\")\n\n        start, end = self.HISTORICAL_SCENARIOS[scenario_name]\n\n        # Get returns during crisis\n        crisis_returns = historical_data.loc[start:end]\n\n        if self.weights is not None:\n            port_returns = (crisis_returns @ self.weights)\n        else:\n            port_returns = crisis_returns\n\n        total_return = (1 + port_returns).prod() - 1\n        max_dd = self._calculate_max_dd(port_returns)\n        worst_day = port_returns.min()\n\n        return {\n            \"scenario\": scenario_name,\n            \"period\": f\"{start} to {end}\",\n            \"total_return\": total_return,\n            \"max_drawdown\": max_dd,\n            \"worst_day\": worst_day,\n            \"volatility\": port_returns.std() * np.sqrt(252)\n        }\n\n    def hypothetical_stress_test(\n        self,\n        shocks: Dict[str, float]\n    ) -> float:\n        \"\"\"\n        Test portfolio against hypothetical shocks.\n\n        Args:\n            shocks: Dict of {asset: shock_return}\n        \"\"\"\n        if self.weights is None:\n            raise ValueError(\"Weights required for hypothetical stress test\")\n\n        total_impact = 0\n        for asset, shock in shocks.items():\n            if asset in self.weights.index:\n                total_impact += self.weights[asset] * shock\n\n        return total_impact\n\n    def monte_carlo_stress(\n        self,\n        n_simulations: int = 10000,\n        horizon_days: int = 21,\n        vol_multiplier: float = 2.0\n    ) -> Dict[str, float]:\n        \"\"\"Monte Carlo stress test with elevated volatility.\"\"\"\n        mean = self.returns.mean()\n        vol = self.returns.std() * vol_multiplier\n\n        simulations = np.random.normal(\n            mean,\n            vol,\n            (n_simulations, horizon_days)\n        )\n\n        total_returns = (1 + simulations).prod(axis=1) - 1\n\n        return {\n            \"expected_loss\": -total_returns.mean(),\n            \"var_95\": -np.percentile(total_returns, 5),\n            \"var_99\": -np.percentile(total_returns, 1),\n            \"worst_case\": -total_returns.min(),\n            \"prob_10pct_loss\": (total_returns \u003C -0.10).mean()\n        }\n\n    def _calculate_max_dd(self, returns: pd.Series) -> float:\n        cumulative = (1 + returns).cumprod()\n        running_max = cumulative.cummax()\n        drawdowns = (cumulative - running_max) \u002F running_max\n        return drawdowns.min()\n```\n\n## Quick Reference\n\n```python\n# Daily usage\nmetrics = RiskMetrics(returns)\nprint(f\"Sharpe: {metrics.sharpe_ratio():.2f}\")\nprint(f\"Max DD: {metrics.max_drawdown():.2%}\")\nprint(f\"VaR 95%: {metrics.var_historical(0.95):.2%}\")\n\n# Full summary\nsummary = metrics.summary()\nfor metric, value in summary.items():\n    print(f\"{metric}: {value:.4f}\")\n```\n\n## Best Practices\n\n### Do's\n\n- **Use multiple metrics** - No single metric captures all risk\n- **Consider tail risk** - VaR isn't enough, use CVaR\n- **Rolling analysis** - Risk changes over time\n- **Stress test** - Historical and hypothetical\n- **Document assumptions** - Distribution, lookback, etc.\n\n### Don'ts\n\n- **Don't rely on VaR alone** - Underestimates tail risk\n- **Don't assume normality** - Returns are fat-tailed\n- **Don't ignore correlation** - Increases in stress\n- **Don't use short lookbacks** - Miss regime changes\n- **Don't forget transaction costs** - Affects realized risk\n",{"name":5,"description":7},"main","87afe6ce96220accf50a345dea46784c8c9f210e","YYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-plugins-claude\u002Fquantitative-trading\u002Fskills\u002Frisk-metrics-calculation",0,"https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base","https:\u002F\u002Fkb.yyc3.top\u002F","https:\u002F\u002Fgithub.com\u002FYYC-Cube","万象归元于云枢 | 深栈智启新纪元","2026-11-10 10:37:32",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill risk-metrics-calculation",{"tool":39,"command":40},"bunx","bunx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill risk-metrics-calculation",{"tool":42,"command":43},"pnpm","pnpm dlx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill risk-metrics-calculation","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-plugins-claude\u002Fquantitative-trading\u002Fskills\u002Frisk-metrics-calculation\u002FSKILL.md",true,[],[48,55,62,69,76,83],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"publishedAt":19},"01M7CTDWHERCXPQCP0K03A86AS","vercel-sandbox","Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include \"Vercel Sandbox browser\", \"microVM Chrome\", \"agent-browser in sandbox\", \"browser automation on Vercel\", or any task requiring Chrome in a Vercel Sandbox.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fvercel-sandbox\u002FSKILL.md",[],[],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":59,"categories":60,"keywords":61,"publishedAt":19},"01M7CTD8D2BNJY54S65M47HEJA","slack","Interact with Slack workspaces using browser automation. Use when the user needs to check unread channels, navigate Slack, send messages, extract data, find information, search conversations, or automate any Slack task. Triggers include \"check my Slack\", \"what channels have unreads\", \"send a message to\", \"search Slack for\", \"extract from Slack\", \"find who said\", or any task requiring programmatic Slack interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fslack\u002FSKILL.md",[],[],{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":68,"publishedAt":19},"01M7CTCSSB8ZP3Q58C3YZDZK1W","electron","Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include \"automate Slack app\", \"control VS Code\", \"interact with Discord app\", \"test this Electron app\", \"connect to desktop app\", or any task requiring automation of a native Electron application.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Felectron\u002FSKILL.md",[],[],{"skillNo":70,"name":71,"nameZh":6,"description":72,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":73,"categories":74,"keywords":75,"publishedAt":19},"01M7CTCBJY76688V4DCZGWFHGQ","dogfood","Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to \"dogfood\", \"QA\", \"exploratory test\", \"find issues\", \"bug hunt\", \"test this app\u002Fsite\u002Fplatform\", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fdogfood\u002FSKILL.md",[],[],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":19},"01M7CTC4H0FFGVEAQR9PA4GA1A","agent-browser","Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to \"open a website\", \"fill out a form\", \"click a button\", \"take a screenshot\", \"scrape data from a page\", \"test this web app\", \"login to a site\", \"automate browser actions\", or any task requiring programmatic web interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fagent-browser\u002FSKILL.md",[],[],{"skillNo":84,"name":85,"nameZh":6,"description":86,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":19},"01M7CTBKVFYBG78FDSABSDJTTQ","shadcn","Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI, including chat interfaces. Provides project context, component docs, and usage examples. Applies when working with shadcn\u002Fui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for \"shadcn init\", \"create an app with --preset\", \"switch to --preset\", and for building a design system or applying a DESIGN.md or brand spec to shadcn\u002Fui.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-UI-界面组件\u002FYYC3-UI-界面组件-ui\u002Fskills\u002Fshadcn\u002FSKILL.md",[],[]]