opencode-skills-antigravity 1.0.11 → 1.0.12

package/bundled-skills/xvary-stock-research/references/methodology.md

@@ -0,0 +1,153 @@
+# XVARY Methodology (Public Framework)
+
+This document is the **public framework** for XVARY Research.
+
+It is intentionally the **menu, not the recipe**: stage names, logic flow, and decision philosophy are published; internal prompts, thresholds, and convergence algorithms are not.
+
+Full narrative: [xvary.com/methodology](https://xvary.com/methodology)
+
+## Research Philosophy
+
+XVARY is built around five principles:
+
+1. **Variant perception first**: value comes from being directionally right where consensus is wrong.
+2. **Evidence before narrative**: facts constrain the story, not the other way around.
+3. **Conviction is earned**: scores reflect cross-validated support, not tone or confidence theater.
+4. **Adversarial challenge is mandatory**: every thesis gets attacked before publication.
+5. **Kill-file discipline**: each call includes explicit thesis-invalidating conditions.
+
+## 22-Stage Operational DAG (21-Stage Research Spine + Finalize)
+
+```mermaid
+flowchart TD
+    s1[directive_selection] --> s2[phase_a]
+    s2 --> s3[data_quality_gate]
+    s3 --> s4[evidence_gap_analysis]
+    s4 --> s5[kvd_hypothesis]
+    s4 --> s6[pane_selection]
+    s6 --> s7[quant_foundation]
+    s7 --> s8[model_quality_gate]
+    s6 --> s9[phase_b]
+    s5 --> s9
+    s9 --> s10[triangulation]
+    s10 --> s11[pillar_discovery]
+    s11 --> s12[phase_c]
+    s11 --> s13[why_tree]
+    s12 --> s14[quality_gate]
+    s13 --> s14
+    s14 --> s15[challenge]
+    s15 --> s16[synthesis]
+    s16 --> s17[audit]
+    s17 --> s18[report_json]
+    s18 --> s19[audience_calibration]
+    s18 --> s20[compliance_audit]
+    s19 --> s21[completion_loop]
+    s20 --> s21
+    s21 --> s22[finalize]
+```
+
+> The operational DAG has 22 nodes in code (`finalize` included). Publicly we refer to the core research spine as the 21-stage methodology and treat finalization as release control.
+
+### Stage Intent (One-Line)
+
+1. `directive_selection`: choose sector/style evidence directives.
+2. `phase_a`: collect baseline facts, filings, market context, and broad evidence.
+3. `data_quality_gate`: block low-integrity factual inputs.
+4. `evidence_gap_analysis`: detect missing evidence and open targeted searches.
+5. `kvd_hypothesis`: identify candidate key value drivers.
+6. `pane_selection`: choose report panes for company profile.
+7. `quant_foundation`: build model scaffolding (valuation/risk context).
+8. `model_quality_gate`: sanity-check model outputs before synthesis.
+9. `phase_b`: run enrichment search and deeper context collection.
+10. `triangulation`: compare evidence across independent reasoning vectors.
+11. `pillar_discovery`: derive weighted thesis pillars.
+12. `phase_c`: execute module-level synthesis in parallel.
+13. `why_tree`: decompose causal claims and dependency chains.
+14. `quality_gate`: run structured quality tests and consistency checks.
+15. `challenge`: adversarially test each pillar and assumptions.
+16. `synthesis`: assemble conviction, variant view, and scenario posture.
+17. `audit`: multi-role verification with follow-up rounds.
+18. `report_json`: build structured report payload.
+19. `audience_calibration`: ensure readability + decision-usefulness.
+20. `compliance_audit`: verify methodology and policy compliance.
+21. `completion_loop`: repair sparse or inconsistent sections.
+22. `finalize`: release gating and artifact finalization.
+
+## Quality Gates (Public Names + What They Check)
+
+- **Data Quality Gate**: missingness, stale fields, broken units, filing coherence.
+- **Model Quality Gate**: sanity bounds, impossible outputs, assumption integrity.
+- **Quality Gate**: cross-module consistency, contradiction flags, evidence sufficiency.
+- **Audience Calibration**: clarity, thesis readability, decision speed under time pressure.
+- **Compliance Audit**: methodology adherence, sourcing hygiene, output policy checks.
+- **Finalize Gate**: final validation + publication readiness.
+
+## 23 Research Modules
+
+1. `kvd`: key value-driver identification and trajectory framing.
+2. `core_facts`: baseline thesis framing and variant setup.
+3. `operations`: revenue engine, segment economics, moat mechanics.
+4. `financials`: profitability, balance-sheet quality, cash conversion.
+5. `valuation`: intrinsic range, scenario math, and expectation gap.
+6. `management`: leadership quality, incentives, and execution credibility.
+7. `competition`: market structure, rival dynamics, strategic pressure.
+8. `risk`: kill criteria, thesis breakers, and downside maps.
+9. `capital_allocation`: buybacks/dividends/M&A capital discipline.
+10. `governance`: board structure, oversight quality, shareholder alignment.
+11. `catalysts`: event map and timing-sensitive thesis triggers.
+12. `product_tech`: product moat, roadmap durability, and innovation path.
+13. `supply_chain`: supplier dependency, resilience, and bottleneck exposure.
+14. `tam`: market size realism, penetration runway, and saturation risk.
+15. `street`: consensus expectations vs. internal thesis.
+16. `macro_sensitivity`: rates/FX/cycle sensitivity mapping.
+17. `value_framework`: investment framework fit + decision rubric.
+18. `quant_profile`: factor, drawdown, and liquidity behavior profile.
+19. `signals`: alternative/leading indicators and signal dashboard.
+20. `derivs`: options/short-interest positioning context.
+21. `earnings_track`: beat/miss quality and guidance reliability.
+22. `history`: strategic timeline and historical analog framing.
+23. `executive_summary`: cross-module synthesis for fast decisioning.
+
+## Conviction Scoring (Concept)
+
+Conviction is built from weighted pillars rather than a single-model output:
+
+- Pillar strength (how well each core claim is supported)
+- Pillar dependency risk (how fragile each claim is)
+- Cross-module consistency (do independent modules agree?)
+- Adversarial challenge survival (did core claims hold up?)
+- Downside asymmetry under identified kill criteria
+
+Weights are dynamic by business model and evidence reliability. Exact calibration is proprietary.
+
+## Kill-File Risks (Concept)
+
+Every thesis is paired with explicit conditions that invalidate it. A kill file is not a downside list; it is the shortest set of assumptions that, if broken, forces re-underwriting.
+
+Typical kill-file categories:
+
+- Structural demand break
+- Unit-economics deterioration
+- Balance-sheet fragility
+- Regulatory/regime shock
+- Management credibility failure
+
+## Five-Vector Triangulation (Concept)
+
+Each ticker is evaluated through five independent vectors before synthesis:
+
+1. **Accounting reality**
+2. **Market-implied expectations**
+3. **Operational execution**
+4. **Strategic position / industry structure**
+5. **Macro-regime sensitivity**
+
+The goal is convergence testing: where vectors agree, conviction rises; where they diverge, uncertainty is made explicit.
+
+## Intentionally Not Published
+
+- Module prompt templates
+- Prompt routing logic and fallback trees
+- Threshold matrices and gating cutoffs
+- Internal convergence scoring mechanics
+- Sector-specific directive libraries

package/bundled-skills/xvary-stock-research/references/scoring.md

@@ -0,0 +1,111 @@
+# XVARY Scores (Public Definitions)
+
+This file defines the **public** score framework used by the skill.
+
+Important: production XVARY systems use proprietary calibrations. The equations below expose the logic shape, not private threshold tables.
+
+## Score Scale
+
+All scores are normalized to `0-100`.
+
+- `80-100`: Strong
+- `60-79`: Constructive
+- `40-59`: Mixed
+- `0-39`: Weak
+
+## Inputs
+
+Inputs come from:
+
+- `tools/edgar.py` (filings + fundamentals)
+- `tools/market.py` (price + valuation context)
+
+The public skill uses the latest annual and quarterly data where available.
+
+## 1) Momentum Score
+
+Measures forward drive in fundamentals + market behavior.
+
+Public formula shape:
+
+`Momentum = 100 * (w1*Growth + w2*Revision + w3*RelativeStrength + w4*OperatingLeverage)`
+
+Component definitions (normalized to `0-1`):
+
+- `Growth`: revenue/EPS growth persistence
+- `Revision`: direction of estimate/expectation changes
+- `RelativeStrength`: recent relative price performance
+- `OperatingLeverage`: incremental profit conversion on growth
+
+## 2) Stability Score
+
+Measures durability and variance control.
+
+Public formula shape:
+
+`Stability = 100 * (w1*MarginStability + w2*CashFlowStability + w3*CyclicalityBuffer + w4*ExecutionConsistency)`
+
+Components:
+
+- `MarginStability`: volatility in gross/operating profile
+- `CashFlowStability`: operating cash-flow consistency
+- `CyclicalityBuffer`: sensitivity to external demand shocks
+- `ExecutionConsistency`: beat/miss and guidance reliability trend
+
+## 3) Financial Health Score
+
+Measures solvency quality and balance-sheet resilience.
+
+Public formula shape:
+
+`FinancialHealth = 100 * (w1*Liquidity + w2*Leverage + w3*Coverage + w4*CashConversion)`
+
+Components:
+
+- `Liquidity`: cash + near-term flexibility
+- `Leverage`: debt load relative to earnings power
+- `Coverage`: debt service coverage strength
+- `CashConversion`: earnings-to-cash realization quality
+
+## 4) Upside Estimate Score
+
+Measures risk-reward asymmetry vs. implied expectations.
+
+Public formula shape:
+
+`Upside = 100 * (w1*IntrinsicGap + w2*ScenarioAsymmetry + w3*CatalystDensity + w4*ExpectationMispricing)`
+
+Components:
+
+- `IntrinsicGap`: conservative value range minus current price
+- `ScenarioAsymmetry`: upside/downside distribution quality
+- `CatalystDensity`: number and quality of near-term unlocks
+- `ExpectationMispricing`: mismatch between consensus and thesis path
+
+## Composite View (Optional)
+
+Some outputs use an optional composite:
+
+`Composite = a*Momentum + b*Stability + c*FinancialHealth + d*Upside`
+
+Weights are intentionally configurable by sector/business model in production.
+
+## Confidence Annotation
+
+Each score can include a confidence tag based on evidence depth:
+
+- `High`: robust multi-source evidence, low internal contradiction
+- `Medium`: adequate evidence, some assumptions open
+- `Low`: sparse data or unresolved contradictions
+
+## Kill Criteria Coupling
+
+Scores are never final without kill criteria.
+
+If a listed kill criterion triggers, the thesis should be re-underwritten regardless of score level.
+
+## Not Included in Public Docs
+
+- Production weight values (`w1..w4`, `a..d`)
+- Threshold cutoffs and regime-specific overrides
+- Internal fallback logic for sparse/contradictory data

package/bundled-skills/xvary-stock-research/tests/test_edgar.py

@@ -0,0 +1,90 @@
+import unittest
+from unittest.mock import Mock, patch
+from typing import Optional
+
+from tools import edgar
+
+
+class EdgarTests(unittest.TestCase):
+    def test_shares_outstanding_does_not_include_weighted_average_concepts(self) -> None:
+        concepts = edgar._FIELD_CONCEPTS["balance_sheet"]["shares_outstanding"]
+        self.assertNotIn("WeightedAverageNumberOfDilutedSharesOutstanding", concepts)
+        self.assertNotIn("WeightedAverageShares", concepts)
+
+    def test_best_entry_uses_concept_priority_before_recency(self) -> None:
+        records = [
+            {
+                "concept": "Revenue",
+                "unit": "USD",
+                "form": "10-K",
+                "period_end": "2026-12-31",
+                "filed": "2027-02-01",
+                "period_months": 12,
+            },
+            {
+                "concept": "Revenues",
+                "unit": "USD",
+                "form": "10-K",
+                "period_end": "2025-12-31",
+                "filed": "2026-02-01",
+                "period_months": 12,
+            },
+        ]
+        best = edgar._best_entry(
+            records,
+            quarterly=False,
+            statement="income_statement",
+            field="revenue",
+        )
+        self.assertIsNotNone(best)
+        assert best is not None
+        self.assertEqual(best["concept"], "Revenues")
+
+    def test_request_json_retries_then_succeeds(self) -> None:
+        class FakeResponse:
+            def __init__(self, status_code: int, payload: Optional[dict] = None) -> None:
+                self.status_code = status_code
+                self._payload = payload or {}
+
+            def raise_for_status(self) -> None:
+                if self.status_code >= 400:
+                    raise edgar.requests.HTTPError(response=self)
+
+            def json(self) -> dict:
+                return self._payload
+
+        session = Mock()
+        session.get.side_effect = [
+            FakeResponse(503),
+            FakeResponse(200, {"ok": True}),
+        ]
+
+        with patch("tools.edgar.time.sleep") as sleep_mock:
+            data = edgar._request_json("https://example.com", session)
+
+        self.assertEqual(data, {"ok": True})
+        self.assertEqual(session.get.call_count, 2)
+        sleep_mock.assert_called_once()
+
+    def test_request_json_raises_after_max_retries(self) -> None:
+        class FakeResponse:
+            def __init__(self, status_code: int) -> None:
+                self.status_code = status_code
+
+            def raise_for_status(self) -> None:
+                raise edgar.requests.HTTPError(response=self)
+
+            def json(self) -> dict:
+                return {}
+
+        session = Mock()
+        session.get.return_value = FakeResponse(503)
+
+        with patch("tools.edgar.time.sleep"):
+            with self.assertRaises(edgar.requests.HTTPError):
+                edgar._request_json("https://example.com", session)
+        self.assertEqual(session.get.call_count, edgar._MAX_RETRIES)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/bundled-skills/xvary-stock-research/tests/test_market.py

@@ -0,0 +1,113 @@
+import unittest
+from unittest.mock import patch
+from typing import Optional
+
+from tools import market
+
+
+class MarketTests(unittest.TestCase):
+    def test_get_ratios_short_circuits_after_first_provider_with_ratios(self) -> None:
+        calls: list[str] = []
+
+        def yahoo(_ticker: str):
+            calls.append("yahoo")
+            return {
+                "provider": "yahoo",
+                "price": 100.0,
+                "pe": 25.0,
+                "dividend_yield_pct": 1.2,
+                "beta": 1.1,
+            }
+
+        def finviz(_ticker: str):
+            calls.append("finviz")
+            return {
+                "provider": "finviz",
+                "price": 100.0,
+                "pe": 18.0,
+                "dividend_yield_pct": 2.0,
+                "beta": 0.9,
+            }
+
+        def stooq(_ticker: str):
+            calls.append("stooq")
+            return {
+                "provider": "stooq",
+                "price": 100.0,
+                "pe": None,
+                "dividend_yield_pct": None,
+                "beta": None,
+            }
+
+        with patch("tools.market._fetch_yahoo", yahoo), patch(
+            "tools.market._fetch_finviz", finviz
+        ), patch("tools.market._fetch_stooq", stooq):
+            result = market.get_ratios("AAPL")
+
+        self.assertEqual(result["provider"], "yahoo")
+        self.assertEqual(calls, ["yahoo"])
+
+    def test_get_ratios_uses_second_provider_when_first_has_no_ratios(self) -> None:
+        calls: list[str] = []
+
+        def yahoo(_ticker: str):
+            calls.append("yahoo")
+            return {
+                "provider": "yahoo",
+                "price": 100.0,
+                "pe": None,
+                "dividend_yield_pct": None,
+                "beta": None,
+            }
+
+        def finviz(_ticker: str):
+            calls.append("finviz")
+            return {
+                "provider": "finviz",
+                "price": 100.0,
+                "pe": 18.0,
+                "dividend_yield_pct": 2.0,
+                "beta": 0.9,
+            }
+
+        def stooq(_ticker: str):
+            calls.append("stooq")
+            return None
+
+        with patch("tools.market._fetch_yahoo", yahoo), patch(
+            "tools.market._fetch_finviz", finviz
+        ), patch("tools.market._fetch_stooq", stooq):
+            result = market.get_ratios("AAPL")
+
+        self.assertEqual(result["provider"], "finviz")
+        self.assertEqual(calls, ["yahoo", "finviz"])
+
+    def test_http_get_json_retries_then_succeeds(self) -> None:
+        class FakeResponse:
+            def __init__(self, status_code: int, payload: Optional[dict] = None) -> None:
+                self.status_code = status_code
+                self._payload = payload or {}
+
+            def raise_for_status(self) -> None:
+                if self.status_code >= 400:
+                    raise market.requests.HTTPError(response=self)
+
+            def json(self) -> dict:
+                return self._payload
+
+        with patch("tools.market.requests.get") as get_mock, patch(
+            "tools.market.time.sleep"
+        ) as sleep_mock:
+            get_mock.side_effect = [
+                FakeResponse(503),
+                FakeResponse(200, {"ok": True}),
+            ]
+            payload = market._http_get_json("https://example.com")
+
+        self.assertEqual(payload, {"ok": True})
+        self.assertEqual(get_mock.call_count, 2)
+        sleep_mock.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()