@drico2008/fincli 0.2.2 → 0.3.1

package/fincli/app/modules/portfolio_risk.py

@@ -0,0 +1,305 @@
+"""Portfolio Risk v2 analytics."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.modules.user_profile import UserProfile
+
+
+@dataclass(frozen=True, slots=True)
+class AssetClassExposure:
+    asset_class: str
+    market_value: float
+    weight: float
+    count: int
+
+
+@dataclass(frozen=True, slots=True)
+class CurrencyExposure:
+    currency: str
+    market_value: float
+    weight: float
+    count: int
+
+
+@dataclass(frozen=True, slots=True)
+class ConcentrationRisk:
+    top_symbol: str
+    top_weight: float
+    level: str
+    note: str
+
+
+@dataclass(frozen=True, slots=True)
+class PortfolioHealth:
+    score: int
+    label: str
+    notes: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class AssetClassWarning:
+    asset_class: str
+    weight: float
+    cap: float
+    level: str
+    note: str
+
+
+@dataclass(frozen=True, slots=True)
+class RiskBudget:
+    profile_gameplay: str
+    equity: float
+    currency: str
+    risk_per_trade: float
+    max_portfolio_risk: float
+    note: str
+
+
+@dataclass(frozen=True, slots=True)
+class PortfolioRiskReport:
+    total_cost_basis: float
+    total_market_value: float
+    realized_pnl: float
+    unrealized_pnl: float
+    total_pnl: float
+    exposure_by_asset_class: dict[str, AssetClassExposure]
+    currency_exposure: dict[str, CurrencyExposure]
+    concentration: ConcentrationRisk
+    health: PortfolioHealth
+    drawdown_estimate: float
+    asset_class_warnings: tuple[AssetClassWarning, ...]
+    risk_budget: RiskBudget
+
+
+def build_portfolio_risk(
+    positions: list[dict[str, object]],
+    market_values: dict[str, tuple[float | None, float | None, float | None]],
+    realized_pnl: float,
+    profile: UserProfile | None = None,
+) -> PortfolioRiskReport:
+    """Build exposure, concentration, PnL, and health score from positions."""
+    total_cost_basis = 0.0
+    total_market_value = 0.0
+    unrealized_pnl = 0.0
+    exposure_values: dict[str, float] = {}
+    exposure_counts: dict[str, int] = {}
+    currency_values: dict[str, float] = {}
+    currency_counts: dict[str, int] = {}
+    symbol_values: dict[str, float] = {}
+    missing_prices = 0
+
+    for row in positions:
+        symbol = str(row["symbol"]).upper()
+        quantity = float(row["quantity"])
+        average_price = float(row["average_price"])
+        cost_basis = quantity * average_price
+        total_cost_basis += cost_basis
+
+        current_price, pnl, _pnl_percent = market_values.get(symbol, (None, None, None))
+        if current_price is None:
+            missing_prices += 1
+            market_value = cost_basis
+        else:
+            market_value = quantity * current_price
+        total_market_value += market_value
+        if pnl is not None:
+            unrealized_pnl += pnl
+
+        asset_class = classify_asset_class(symbol)
+        exposure_values[asset_class] = exposure_values.get(asset_class, 0.0) + market_value
+        exposure_counts[asset_class] = exposure_counts.get(asset_class, 0) + 1
+        currency = str(row.get("currency", "USD")).upper()
+        currency_values[currency] = currency_values.get(currency, 0.0) + market_value
+        currency_counts[currency] = currency_counts.get(currency, 0) + 1
+        symbol_values[symbol] = market_value
+
+    exposure_by_asset_class = {
+        asset_class: AssetClassExposure(
+            asset_class=asset_class,
+            market_value=value,
+            weight=_weight(value, total_market_value),
+            count=exposure_counts.get(asset_class, 0),
+        )
+        for asset_class, value in sorted(exposure_values.items())
+    }
+    currency_exposure = {
+        currency: CurrencyExposure(
+            currency=currency,
+            market_value=value,
+            weight=_weight(value, total_market_value),
+            count=currency_counts.get(currency, 0),
+        )
+        for currency, value in sorted(currency_values.items())
+    }
+    concentration = _concentration(symbol_values, total_market_value)
+    total_pnl = realized_pnl + unrealized_pnl
+    drawdown_estimate = _drawdown_estimate(unrealized_pnl, total_cost_basis)
+    warnings = _asset_class_warnings(exposure_by_asset_class)
+    risk_budget = _risk_budget(profile)
+    health = _health_score(
+        positions_count=len(positions),
+        top_weight=concentration.top_weight,
+        missing_prices=missing_prices,
+        total_pnl=total_pnl,
+        total_cost_basis=total_cost_basis,
+        asset_class_count=len(exposure_by_asset_class),
+        drawdown_estimate=drawdown_estimate,
+        warning_count=len(warnings),
+    )
+    return PortfolioRiskReport(
+        total_cost_basis=total_cost_basis,
+        total_market_value=total_market_value,
+        realized_pnl=realized_pnl,
+        unrealized_pnl=unrealized_pnl,
+        total_pnl=total_pnl,
+        exposure_by_asset_class=exposure_by_asset_class,
+        currency_exposure=currency_exposure,
+        concentration=concentration,
+        health=health,
+        drawdown_estimate=drawdown_estimate,
+        asset_class_warnings=warnings,
+        risk_budget=risk_budget,
+    )
+
+
+def classify_asset_class(symbol: str) -> str:
+    normalized = symbol.upper()
+    if normalized.endswith("-USD") or normalized.endswith("USDT") or normalized in {"BTC", "ETH", "SOL", "BNB"}:
+        return "crypto"
+    if normalized.endswith("=X") or len(normalized) == 6 and normalized.isalpha():
+        return "forex"
+    if normalized.startswith("^") or normalized in {"SPX", "NASDAQ", "DJI", "DAX", "NIKKEI", "HSI"}:
+        return "index"
+    if normalized.endswith("=F") or normalized in {"XAUUSD", "XAGUSD", "WTI", "BRENT", "GOLD", "SILVER"}:
+        return "commodity"
+    if normalized.endswith(".JK") or normalized.endswith(".L") or normalized.endswith(".TO") or normalized.isalpha():
+        return "equity"
+    return "other"
+
+
+def _concentration(symbol_values: dict[str, float], total_market_value: float) -> ConcentrationRisk:
+    if not symbol_values or total_market_value <= 0:
+        return ConcentrationRisk("-", 0.0, "empty", "No market value available.")
+    top_symbol, top_value = max(symbol_values.items(), key=lambda item: item[1])
+    top_weight = _weight(top_value, total_market_value)
+    if top_weight >= 60:
+        level = "high"
+        note = "Top position dominates portfolio."
+    elif top_weight >= 35:
+        level = "medium"
+        note = "Top position needs monitoring."
+    else:
+        level = "healthy"
+        note = "No single position dominates."
+    return ConcentrationRisk(top_symbol, top_weight, level, note)
+
+
+def _health_score(
+    positions_count: int,
+    top_weight: float,
+    missing_prices: int,
+    total_pnl: float,
+    total_cost_basis: float,
+    asset_class_count: int,
+    drawdown_estimate: float,
+    warning_count: int,
+) -> PortfolioHealth:
+    score = 100
+    notes: list[str] = []
+    if positions_count == 0:
+        return PortfolioHealth(0, "empty", ("No positions.",))
+    if positions_count < 3:
+        score -= 15
+        notes.append("few positions")
+    if asset_class_count < 2:
+        score -= 10
+        notes.append("single asset class")
+    if top_weight >= 60:
+        score -= 25
+        notes.append("high concentration")
+    elif top_weight >= 35:
+        score -= 10
+        notes.append("medium concentration")
+    if missing_prices:
+        score -= min(30, missing_prices * 10)
+        notes.append(f"{missing_prices} missing price(s)")
+    if warning_count:
+        score -= min(20, warning_count * 8)
+        notes.append(f"{warning_count} asset-class cap warning(s)")
+    if drawdown_estimate <= -25:
+        score -= 15
+        notes.append("deep drawdown estimate")
+    pnl_ratio = (total_pnl / total_cost_basis * 100) if total_cost_basis else 0.0
+    if pnl_ratio <= -20:
+        score -= 20
+        notes.append("large drawdown")
+    elif pnl_ratio < 0:
+        score -= 8
+        notes.append("negative total PnL")
+
+    score = max(0, min(100, score))
+    if score >= 80:
+        label = "healthy"
+    elif score >= 60:
+        label = "watch"
+    elif score >= 40:
+        label = "caution"
+    else:
+        label = "high risk"
+    return PortfolioHealth(score, label, tuple(notes) or ("balanced baseline",))
+
+
+def _weight(value: float, total: float) -> float:
+    return (value / total * 100) if total else 0.0
+
+
+def _drawdown_estimate(unrealized_pnl: float, total_cost_basis: float) -> float:
+    if total_cost_basis <= 0:
+        return 0.0
+    return min(0.0, unrealized_pnl / total_cost_basis * 100)
+
+
+def _asset_class_warnings(exposures: dict[str, AssetClassExposure]) -> tuple[AssetClassWarning, ...]:
+    caps = {"crypto": 25.0, "forex": 40.0, "commodity": 35.0, "index": 50.0, "equity": 70.0, "other": 25.0}
+    warnings: list[AssetClassWarning] = []
+    for exposure in exposures.values():
+        cap = caps.get(exposure.asset_class, 25.0)
+        if exposure.weight > cap:
+            warnings.append(
+                AssetClassWarning(
+                    asset_class=exposure.asset_class,
+                    weight=exposure.weight,
+                    cap=cap,
+                    level="high" if exposure.weight >= cap + 20 else "watch",
+                    note=f"{exposure.asset_class} exposure {exposure.weight:.2f}% exceeds cap {cap:.2f}%.",
+                )
+            )
+    return tuple(warnings)
+
+
+def _risk_budget(profile: UserProfile | None) -> RiskBudget:
+    if profile is None:
+        return RiskBudget("unprofiled", 0.0, "USD", 0.0, 0.0, "Run /profile set to enable risk budget.")
+    gameplay = profile.gameplay
+    if gameplay == "Scalper":
+        per_trade_pct = 1.0
+        max_portfolio_pct = 5.0
+    elif gameplay == "Intra day":
+        per_trade_pct = 1.25
+        max_portfolio_pct = 7.5
+    elif gameplay == "Day trade":
+        per_trade_pct = 1.5
+        max_portfolio_pct = 10.0
+    else:
+        per_trade_pct = 2.0
+        max_portfolio_pct = 12.0
+    return RiskBudget(
+        profile_gameplay=gameplay,
+        equity=profile.equity,
+        currency=profile.currency,
+        risk_per_trade=profile.equity * per_trade_pct / 100,
+        max_portfolio_risk=profile.equity * max_portfolio_pct / 100,
+        note=f"{per_trade_pct:.2f}% per trade, {max_portfolio_pct:.2f}% max portfolio risk budget.",
+    )

package/fincli/app/plugins/loader.py

@@ -1,6 +1,6 @@
 """Local plugin discovery for FinCLI.
 
-Plugins are intentionally manifest-first in v0.2.2: FinCLI reads metadata and
+Plugins are intentionally manifest-first in v0.3.1: FinCLI reads metadata and
 exposes status, but does not execute plugin code yet. This keeps the plugin
 surface useful without creating a security footgun.
 """

package/fincli/app/providers/reliability.py

@@ -0,0 +1,86 @@
+"""Provider reliability contracts and status classification."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from fincli.app.utils.errors import RateLimitError
+
+
+STATUS_OK = "ok"
+STATUS_AUTH_FAILED = "auth_failed"
+STATUS_RATE_LIMITED = "rate_limited"
+STATUS_ENTITLEMENT_MISSING = "entitlement_missing"
+STATUS_PARTIAL_DATA = "partial_data"
+STATUS_SCHEDULE_ONLY = "schedule_only"
+STATUS_UNAVAILABLE = "unavailable"
+
+GRANULAR_STATUSES = (
+    STATUS_OK,
+    STATUS_AUTH_FAILED,
+    STATUS_RATE_LIMITED,
+    STATUS_ENTITLEMENT_MISSING,
+    STATUS_PARTIAL_DATA,
+    STATUS_SCHEDULE_ONLY,
+    STATUS_UNAVAILABLE,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderResult:
+    """Standard result envelope for provider calls."""
+
+    provider: str
+    operation: str
+    status: str
+    realtime_label: str = "unknown"
+    source: str = ""
+    data_quality: str = "unknown"
+    missing_fields: tuple[str, ...] = ()
+    message: str = ""
+
+
+def classify_provider_error(exc: BaseException) -> str:
+    """Classify provider failures into stable user-facing reliability statuses."""
+    if isinstance(exc, RateLimitError):
+        return STATUS_RATE_LIMITED
+
+    text = f"{exc} {getattr(exc, 'help_text', '') or ''}".lower()
+    if "429" in text or "rate limit" in text or "too many request" in text:
+        return STATUS_RATE_LIMITED
+    if "401" in text or "unauthorized" in text or "invalid key" in text or "api key" in text and "belum" in text:
+        return STATUS_AUTH_FAILED
+    if "403" in text or "entitlement" in text or "plan" in text or "premium" in text or "forbidden" in text:
+        return STATUS_ENTITLEMENT_MISSING
+    if "empty" in text or "kosong" in text or "no data" in text or "missing" in text:
+        return STATUS_PARTIAL_DATA
+    return STATUS_UNAVAILABLE
+
+
+def classify_payload(operation: str, payload: Any) -> tuple[str, tuple[str, ...]]:
+    """Classify successful provider payload completeness."""
+    if payload is None:
+        return STATUS_PARTIAL_DATA, (operation,)
+    if isinstance(payload, list) and not payload:
+        return STATUS_PARTIAL_DATA, (operation,)
+    if operation == "quote" and getattr(payload, "price", None) is None:
+        return STATUS_PARTIAL_DATA, ("price",)
+    if operation == "fundamentals":
+        missing = tuple(
+            field
+            for field in ("market_cap", "pe_ratio", "eps", "revenue", "sector", "industry")
+            if getattr(payload, field, None) in (None, "")
+        )
+        return (STATUS_PARTIAL_DATA if missing else STATUS_OK), missing
+    return STATUS_OK, ()
+
+
+def result_style(status: str) -> str:
+    """Return a Rich style name for reliability statuses."""
+    if status == STATUS_OK:
+        return "green"
+    if status in {STATUS_AUTH_FAILED, STATUS_RATE_LIMITED, STATUS_ENTITLEMENT_MISSING, STATUS_UNAVAILABLE}:
+        return "red"
+    return "yellow"
+

package/fincli/app/research/__init__.py

@@ -1,7 +1,8 @@
 """Research workspace package."""
 
 from fincli.app.research.engine import ResearchEngine
+from fincli.app.research.exporter import write_research_report
 from fincli.app.research.formatter import format_research_brief
 from fincli.app.research.models import ResearchBrief
 
-__all__ = ["ResearchBrief", "ResearchEngine", "format_research_brief"]
+__all__ = ["ResearchBrief", "ResearchEngine", "format_research_brief", "write_research_report"]

package/fincli/app/research/engine.py

@@ -27,10 +27,16 @@ class ResearchEngine:
                 symbol=brief.symbol,
                 mode=brief.mode,
                 overview=brief.overview,
+                snapshot=brief.snapshot,
+                signal=brief.signal,
+                risk=brief.risk,
+                missing_data=brief.missing_data,
+                source_quality=brief.source_quality,
                 decision_points=brief.decision_points,
                 risks=brief.risks,
                 final_summary=brief.final_summary,
                 ai_summary=response.content,
+                report_notes=brief.report_notes,
             )
         return brief
 
@@ -52,8 +58,20 @@ def _brief_from_overview(overview: MarketOverview, mode: str) -> ResearchBrief:
     if overview.news:
         decision_points.append(f"Latest news: {overview.news[0].title} ({overview.news[0].source}).")
 
+    missing_data = ", ".join(overview.data_quality.missing_fields) if overview.data_quality.missing_fields else "none"
+    source_quality = (
+        f"{overview.data_quality.score}/100 | reliability={overview.data_quality.reliability_status} | "
+        f"provider={overview.data_quality.provider}"
+    )
+    signal = _research_signal(overview)
+    risk = _research_risk(overview)
+    snapshot = (
+        f"{overview.symbol}: {technical.trend_bias} trend, {structure.trend} structure, "
+        f"price {overview.quote.price} {overview.quote.currency}, data {overview.data_quality.score}/100."
+    )
+
     risks = [
-        f"Data quality {overview.data_quality.score}/100; provider label {overview.data_quality.provider}.",
+        f"Source quality: {source_quality}.",
         "Use confirmation and invalidation; do not treat this brief as financial advice.",
     ]
     if structure.change_of_character:
@@ -61,15 +79,59 @@ def _brief_from_overview(overview: MarketOverview, mode: str) -> ResearchBrief:
     if technical.rsi is not None and (technical.rsi > 75 or technical.rsi < 25):
         risks.append("RSI is at an extreme; avoid chasing without confirmation.")
 
-    final_summary = (
-        f"{overview.symbol} is a {technical.trend_bias} / {structure.trend} setup with "
-        f"{overview.data_quality.score}/100 data quality. Focus on support/resistance reaction and news/fundamental confirmation."
+    final_summary = _final_summary(overview, signal, risk, missing_data)
+    report_notes = (
+        f"Snapshot: {snapshot}",
+        f"Signal: {signal}",
+        f"Risk: {risk}",
+        f"Missing data: {missing_data}",
+        f"Source quality: {source_quality}",
+        "Not financial advice.",
     )
     return ResearchBrief(
         symbol=overview.symbol,
         mode=mode,
         overview=overview,
+        snapshot=snapshot,
+        signal=signal,
+        risk=risk,
+        missing_data=missing_data,
+        source_quality=source_quality,
         decision_points=decision_points[:6],
         risks=risks[:4],
         final_summary=final_summary,
+        report_notes=report_notes,
+    )
+
+
+def _research_signal(overview: MarketOverview) -> str:
+    trend = overview.technical.trend_bias.lower()
+    structure = overview.structure.trend.lower()
+    rsi = overview.technical.rsi
+    if overview.data_quality.reliability_status != "ok":
+        return "CAUTION - data incomplete; verify provider source first."
+    if trend == "bullish" and structure == "bullish" and (rsi is None or rsi < 75):
+        return "BULLISH WATCH - only after support/retest confirmation."
+    if trend == "bearish" and structure == "bearish" and (rsi is None or rsi > 25):
+        return "BEARISH WATCH - only after resistance/rejection confirmation."
+    return "CAUTION - mixed or extended setup; wait for confirmation."
+
+
+def _research_risk(overview: MarketOverview) -> str:
+    risks: list[str] = []
+    if overview.structure.change_of_character:
+        risks.append("CHoCH detected")
+    if overview.technical.rsi is not None and overview.technical.rsi > 75:
+        risks.append("RSI overbought")
+    if overview.technical.rsi is not None and overview.technical.rsi < 25:
+        risks.append("RSI oversold")
+    if overview.data_quality.missing_fields:
+        risks.append(f"missing {', '.join(overview.data_quality.missing_fields)}")
+    return "; ".join(risks) if risks else "standard market risk; define invalidation before entry"
+
+
+def _final_summary(overview: MarketOverview, signal: str, risk: str, missing_data: str) -> str:
+    return (
+        f"{overview.symbol}: {signal}. Key risk: {risk}. "
+        f"Missing data: {missing_data}. Treat this as research context, not financial advice."
     )

package/fincli/app/research/exporter.py

@@ -0,0 +1,91 @@
+"""Export helpers for Research Engine v2 reports."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from fincli.app.research.models import ResearchBrief
+from fincli.app.utils.errors import CommandError
+
+
+def write_research_report(brief: ResearchBrief, fmt: str, target: str | Path) -> Path:
+    report_format = fmt.lower()
+    path = _safe_research_path(target, report_format)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if report_format == "json":
+        path.write_text(json.dumps(_research_payload(brief), indent=2, default=str), encoding="utf-8")
+        return path
+    if report_format in {"md", "markdown"}:
+        path.write_text(_research_markdown(brief), encoding="utf-8")
+        return path
+    raise CommandError("Research export format harus md atau json.")
+
+
+def _safe_research_path(target: str | Path, fmt: str) -> Path:
+    path = Path(target).expanduser()
+    if any(part == ".." for part in path.parts):
+        raise CommandError("Research export path tidak boleh mengandung '..'.")
+    allowed = {".md", ".json"} if fmt in {"md", "markdown", "json"} else set()
+    if path.suffix.lower() not in allowed:
+        raise CommandError("Research export path harus berakhir .md atau .json.")
+    return path
+
+
+def _research_payload(brief: ResearchBrief) -> dict[str, Any]:
+    return {
+        "symbol": brief.symbol,
+        "mode": brief.mode,
+        "snapshot": brief.snapshot,
+        "signal": brief.signal,
+        "risk": brief.risk,
+        "missing_data": brief.missing_data,
+        "source_quality": brief.source_quality,
+        "decision_points": brief.decision_points,
+        "risks": brief.risks,
+        "final_summary": brief.final_summary,
+        "ai_summary": brief.ai_summary,
+        "report_notes": list(brief.report_notes),
+        "disclaimer": "Not financial advice.",
+    }
+
+
+def _research_markdown(brief: ResearchBrief) -> str:
+    notes = "\n".join(f"- {item}" for item in brief.report_notes)
+    points = "\n".join(f"- {item}" for item in brief.decision_points)
+    risks = "\n".join(f"- {item}" for item in brief.risks)
+    return "\n".join(
+        [
+            f"# FinCLI Research Report: {brief.symbol}",
+            "",
+            f"- Mode: {brief.mode}",
+            f"- Snapshot: {brief.snapshot}",
+            f"- Signal: {brief.signal}",
+            f"- Risk: {brief.risk}",
+            f"- Missing Data: {brief.missing_data}",
+            f"- Source Quality: {brief.source_quality}",
+            "",
+            "## Decision Points",
+            "",
+            points or "- None.",
+            "",
+            "## Risk Notes",
+            "",
+            risks or "- None.",
+            "",
+            "## Report Notes",
+            "",
+            notes or "- None.",
+            "",
+            "## Final Summary",
+            "",
+            brief.final_summary,
+            "",
+            "## Disclaimer",
+            "",
+            "Not financial advice.",
+            "",
+        ]
+    )
+

package/fincli/app/research/formatter.py

@@ -9,14 +9,19 @@ from fincli.app.utils.formatting import semantic_text
 
 
 def format_research_brief(brief: ResearchBrief) -> Table:
-    table = Table(title=f"Research Brief: {brief.symbol} | {brief.mode}", expand=True)
+    table = Table(title=f"Research Center: {brief.symbol} | {brief.mode} | Research Brief v2", expand=True)
     table.add_column("Section", style="cyan", no_wrap=True)
     table.add_column("Description", overflow="fold")
-    table.add_row("Data Quality", semantic_text(f"{brief.overview.data_quality.score}/100 | {brief.overview.data_quality.provider}"))
-    table.add_row("Decision Points", semantic_text("\n".join(f"- {point}" for point in brief.decision_points)))
-    table.add_row("Risks", semantic_text("\n".join(f"- {risk}" for risk in brief.risks)))
+    table.add_row("Snapshot", semantic_text(brief.snapshot))
+    table.add_row("Signal", semantic_text(brief.signal))
+    table.add_row("Risk", semantic_text(brief.risk))
+    table.add_row("Missing Data", semantic_text(brief.missing_data))
+    table.add_row("Source Quality", semantic_text(brief.source_quality))
+    table.add_row("Decision Points", semantic_text(" | ".join(brief.decision_points[:2])))
+    if brief.mode == "report":
+        table.add_row("Report Notes", semantic_text("\n".join(f"- {item}" for item in brief.report_notes)))
     if brief.ai_summary:
         table.add_row("AI Summary", brief.ai_summary)
     table.add_row("Final Summary", semantic_text(brief.final_summary))
-    table.caption = "Research output is informational only, not financial advice."
+    table.caption = "Research output is informational only. Not financial advice."
     return table

package/fincli/app/research/models.py

@@ -12,7 +12,13 @@ class ResearchBrief:
     symbol: str
     mode: str
     overview: MarketOverview
+    snapshot: str
+    signal: str
+    risk: str
+    missing_data: str
+    source_quality: str
     decision_points: list[str]
     risks: list[str]
     final_summary: str
     ai_summary: str = ""
+    report_notes: tuple[str, ...] = ()

package/fincli/app/research/prompt_builder.py

@@ -6,10 +6,11 @@ from fincli.app.research.models import ResearchBrief
 
 
 RESEARCH_WORKSPACE_PROMPT = """
-You are FinCLI Research Workspace.
+You are FinCLI Research Workspace, operating as Research Engine v2.
 
 Rules:
 - Build a concise investment/trading research note from the provided data only.
+- Output must focus on snapshot, signal, risk, missing data, source quality.
 - Do not invent price, news, fundamentals, or certainty.
 - Do not copy the opening summary as the final summary.
 - Prioritize decision-useful points over long explanation.
@@ -36,6 +37,12 @@ def build_research_prompt(brief: ResearchBrief) -> str:
         f"{RESEARCH_WORKSPACE_PROMPT}\n\n"
         f"Symbol: {brief.symbol}\n"
         f"Mode: {brief.mode}\n"
+        "Required focus: snapshot, signal, risk, missing data, source quality.\n"
+        f"Snapshot: {brief.snapshot}\n"
+        f"Signal: {brief.signal}\n"
+        f"Risk: {brief.risk}\n"
+        f"Missing Data: {brief.missing_data}\n"
+        f"Source Quality: {brief.source_quality}\n"
         f"Quote: {overview.quote.price} {overview.quote.currency} via {overview.quote.provider} ({overview.quote.status})\n"
         f"Data Quality: {overview.data_quality.score}/100; OHLCV={overview.data_quality.ohlcv}; News={overview.data_quality.news}; Fundamentals={overview.data_quality.fundamentals}\n"
         f"Technical: trend={overview.technical.trend_bias}; rsi={overview.technical.rsi}; macd={overview.technical.macd}; support={overview.technical.support}; resistance={overview.technical.resistance}; atr={overview.technical.atr}\n"

package/fincli/app/services/macro_data.py

@@ -19,7 +19,7 @@ class MacroIndicator:
 class MacroDataService:
     """Return macro context from free fallback datasets.
 
-    v0.2.2 keeps this deterministic/offline so /macro remains usable without API keys.
+    v0.3.1 keeps this deterministic/offline so /macro remains usable without API keys.
     Provider-backed DBnomics/FRED/World Bank adapters can hydrate this shape later.
     """