@drico2008/fincli 0.3.1 → 0.4.0

package/fincli/app/cli/router.py

@@ -16,10 +16,10 @@ from rich.panel import Panel
 from rich.table import Table
 
 from fincli.app.cli.commands import CommandRegistry
-from fincli.app.analysis.analyzer import build_market_analysis_prompt, build_technical_ai_summary
-from fincli.app.analysis.backtest import BacktestResult, run_backtest
-from fincli.app.analysis.gameplay_plan import format_gameplay_context
-from fincli.app.agents.registry import Agent, AgentRegistry
+from fincli.app.analysis.analyzer import build_market_analysis_prompt, build_technical_ai_summary
+from fincli.app.analysis.backtest import BacktestResult, run_backtest
+from fincli.app.analysis.gameplay_plan import format_gameplay_context
+from fincli.app.agents.registry import Agent, AgentRegistry
 from fincli.app.analysis.assistant_context import (
     build_web_research_answer_prompt,
     build_fincli_assistant_prompt,
@@ -32,74 +32,85 @@ from fincli.app.analysis.market_structure import MarketStructureSummary, analyze
 from fincli.app.analysis.multi_timeframe import MultiTimeframeAnalysis, analyze_multi_timeframe
 from fincli.app.analysis.technical_debate import TechnicalDebate, format_debate, run_technical_debate
 from fincli.app.analysis.technical_signal import TechnicalSignal, format_signal
-from fincli.app.modules.economic_calendar import (
-    EconomicCalendarService,
-    EconomicEvent,
-    PublicEconomicCalendarService,
-    calendar_summary,
-    default_calendar_window,
-    economic_event_rows,
+from fincli.app.modules.economic_calendar import (
+    EconomicCalendarService,
+    EconomicEvent,
+    PublicEconomicCalendarService,
+    calendar_summary,
+    default_calendar_window,
+    economic_event_rows,
     fallback_events,
     filter_events,
 )
 from fincli.app.modules.alerts import AlertCheckResult, AlertService, evaluate_alert
 from fincli.app.modules.exporter import export_rows
 from fincli.app.modules.journal_analytics import JournalStats, build_journal_review_prompt, calculate_journal_stats
-from fincli.app.modules.journal import JournalService
-from fincli.app.modules.portfolio import PortfolioService
-from fincli.app.modules.portfolio_risk import PortfolioRiskReport, build_portfolio_risk
-from fincli.app.modules.scanner import ScanResult, scan_symbols
-from fincli.app.modules.session_history import SessionHistoryService
-from fincli.app.modules.transactions import TransactionService
-from fincli.app.modules.user_profile import UserProfile, UserProfileService
-from fincli.app.modules.watchlist import WatchlistService
-from fincli.app.connectors.catalog import Connector, ConnectorCatalog
-from fincli.app.connectors.news_connectors import (
-    NewsConnectorCatalog,
-    NewsConnectorManager,
-    NewsConnectorSpec,
-    news_connector_secret_key,
-)
-from fincli.app.modules.reports import write_market_report
+from fincli.app.modules.journal import JournalService
+from fincli.app.modules.portfolio import PortfolioService
+from fincli.app.modules.portfolio_risk import PortfolioRiskReport, build_portfolio_risk
+from fincli.app.modules.scanner import ScanResult, scan_symbols
+from fincli.app.modules.session_history import SessionHistoryService
+from fincli.app.modules.transactions import TransactionService
+from fincli.app.modules.trading import (
+    BrokerCatalog,
+    BrokerIntegration,
+    PaperTradingEngine,
+    RealtimeConnector,
+    RealtimeConnectorCatalog,
+)
+from fincli.app.modules.user_profile import UserProfile, UserProfileService
+from fincli.app.modules.watchlist import WatchlistService
+from fincli.app.connectors.catalog import Connector, ConnectorCatalog
+from fincli.app.connectors.news_connectors import (
+    NewsConnectorCatalog,
+    NewsConnectorManager,
+    NewsConnectorSpec,
+    news_connector_secret_key,
+)
+from fincli.app.diagnostics.capabilities import capability_rows, capability_summary
+from fincli.app.diagnostics.runtime import check_runtime_environment
+from fincli.app.modules.reports import write_market_report
 from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
 from fincli.app.providers.ai.manager import AIProviderManager
-from fincli.app.providers.market.base import (
-    BaseMarketProvider,
-    FundamentalSnapshot,
-    NewsItem,
-    ProviderEntitlement,
+from fincli.app.providers.market.base import (
+    BaseMarketProvider,
+    FundamentalSnapshot,
+    NewsItem,
+    ProviderEntitlement,
     Quote,
     SymbolSearchResult,
-)
-from fincli.app.providers.market.manager import MarketProviderManager
-from fincli.app.providers.market.symbols import provider_symbol_matrix, search_symbol_catalog
-from fincli.app.providers.market.yfinance_provider import YahooTable, YFinanceProvider
-from fincli.app.providers.reliability import (
-    STATUS_OK,
-    STATUS_PARTIAL_DATA,
-    STATUS_SCHEDULE_ONLY,
-    STATUS_UNAVAILABLE,
-)
-from fincli.app.plugins.loader import PluginLoader, PluginManifest
-from fincli.app.services.market_data import MarketDataService
-from fincli.app.services.market_overview import MarketOverview, build_market_overview
-from fincli.app.services.macro_data import MacroDataService, MacroIndicator
-from fincli.app.services.news_aggregator import NewsAggregator, NewsDesk
-from fincli.app.services.web_research import (
+)
+from fincli.app.providers.market.manager import MarketProviderManager
+from fincli.app.providers.market.symbols import SymbolResolver, search_symbol_catalog
+from fincli.app.providers.market.yfinance_provider import YahooTable, YFinanceProvider
+from fincli.app.providers.reliability import (
+    STATUS_OK,
+    STATUS_PARTIAL_DATA,
+    STATUS_SCHEDULE_ONLY,
+    STATUS_UNAVAILABLE,
+)
+from fincli.app.plugins.loader import PluginLoader, PluginManifest
+from fincli.app.services.market_data import MarketDataService
+from fincli.app.services.market_overview import MarketOverview, build_market_overview
+from fincli.app.services.data_quality import DataQualityReport
+from fincli.app.services.data_trust import build_data_trust_gate
+from fincli.app.services.macro_data import MacroDataService, MacroIndicator
+from fincli.app.services.news_aggregator import NewsAggregator, NewsDesk
+from fincli.app.services.web_research import (
     WebResearchService,
     WebSearchResult,
     build_web_research_context,
     should_use_web_research,
-)
-from fincli.app.research import ResearchEngine, format_research_brief, write_research_report
+)
+from fincli.app.research import ResearchEngine, format_research_brief, write_research_report
 from fincli.app.storage.cache import TTLCache
 from fincli.app.storage.config import ConfigManager
 from fincli.app.storage.database import FinCLIDatabase
-from fincli.app.storage.market_cache import MarketCache
-from fincli.app.storage.provider_metrics import ProviderMetricsStore
-from fincli.app.storage.secrets import clear_secrets, read_secrets, save_secret
+from fincli.app.storage.market_cache import MarketCache
+from fincli.app.storage.provider_metrics import ProviderMetricsStore
+from fincli.app.storage.secrets import clear_secrets, read_secrets, save_secret
 from fincli.app.utils.errors import CommandError, FinCLIError
-from fincli.app.utils.formatting import AIResponseView, MarkdownBlock, semantic_text
+from fincli.app.utils.formatting import AIResponseView, MarkdownBlock, semantic_text
 
 
 @dataclass(slots=True)
@@ -124,29 +135,38 @@ class CommandRouter:
         self.config = config or ConfigManager()
         self.db = db or FinCLIDatabase()
         self.registry = registry or CommandRegistry()
-        self.cache: TTLCache[object] = TTLCache(self.config.settings.cache_ttl_seconds)
-        self.market_cache = MarketCache(self.db)
-        self.provider_metrics_store = ProviderMetricsStore(self.db)
-        self.market_manager = MarketProviderManager()
+        self.cache: TTLCache[object] = TTLCache(self.config.settings.cache_ttl_seconds)
+        self.market_cache = MarketCache(self.db)
+        self.provider_metrics_store = ProviderMetricsStore(self.db)
+        self.market_manager = MarketProviderManager()
+        self.symbol_resolver = SymbolResolver()
         self.market_service = self._build_market_service(market_provider)
         self.market_provider = self.market_service.primary_provider
         self.ai_provider = ai_provider or AIProviderManager().create(self.config.settings.ai_provider)
         self.watchlist = WatchlistService(self.db)
         self.portfolio = PortfolioService(self.db)
         self.alerts = AlertService(self.db)
-        self.transactions = TransactionService(self.db, self.portfolio)
-        self.journal = JournalService(self.db)
-        self.user_profiles = UserProfileService(self.db)
-        self.history = SessionHistoryService(self.db)
-        self.session_id = self.history.start_session()
-        self.web_research = WebResearchService()
-        self.macro_data = MacroDataService()
-        self.agent_registry = AgentRegistry()
-        self.connector_catalog = ConnectorCatalog()
-        self.news_connector_catalog = NewsConnectorCatalog()
-        self.news_connectors = NewsConnectorManager(self.news_connector_catalog)
+        self.transactions = TransactionService(self.db, self.portfolio)
+        self.paper_trading = PaperTradingEngine(self.db)
+        self.broker_catalog = BrokerCatalog()
+        self.realtime_connector_catalog = RealtimeConnectorCatalog()
+        self.journal = JournalService(self.db)
+        self.user_profiles = UserProfileService(self.db)
+        self.history = SessionHistoryService(self.db)
+        self.session_id = self.history.start_session()
+        self.web_research = WebResearchService()
+        self.macro_data = MacroDataService()
+        self.agent_registry = AgentRegistry()
+        self.connector_catalog = ConnectorCatalog()
+        self.news_connector_catalog = NewsConnectorCatalog()
+        self.news_connectors = NewsConnectorManager(self.news_connector_catalog)
 
     def route(self, raw: str) -> CommandResult:
+        if not isinstance(raw, str):
+            return CommandResult(
+                Panel("Command harus berupa teks. Contoh: /help", title="Error", border_style="red"),
+                status="error",
+            )
         result = self._route(raw)
         self._record_history(raw, result)
         return result
@@ -156,7 +176,10 @@ class CommandRouter:
         if not raw:
             return CommandResult(Panel("Ketik /help untuk melihat command.", title="FinCLI"))
         if not raw.startswith("/"):
-            return CommandResult(Panel("Command harus diawali slash. Contoh: /help", title="Invalid Input"))
+            return CommandResult(
+                Panel("Command harus diawali slash. Contoh: /help", title="Invalid Input", border_style="red"),
+                status="error",
+            )
 
         try:
             if raw.lower().startswith("/export "):
@@ -187,32 +210,36 @@ class CommandRouter:
                 return self._ai_model(args)
             if root == "/news_model":
                 return self._news_model(args)
-            if root == "/provider":
-                return self._provider(args)
-            if root == "/symbol":
-                return self._symbol(args)
-            if root == "/research":
-                return self._research(args)
-            if root == "/macro":
-                return self._macro(args)
-            if root == "/profile":
-                return self._profile(args)
-            if root == "/doctor":
-                return self._doctor(args)
-            if root == "/setup":
-                return self._setup(args)
-            if root == "/secrets":
-                return self._secrets(args)
-            if root == "/privacy":
-                return self._privacy(args)
-            if root == "/agent":
-                return self._agent(args)
-            if root == "/connector":
-                return self._connector(args)
-            if root == "/plugin":
-                return self._plugin(args)
-            if root == "/cache":
-                return self._cache(args)
+            if root == "/provider":
+                return self._provider(args)
+            if root == "/symbol":
+                return self._symbol(args)
+            if root == "/research":
+                return self._research(args)
+            if root == "/macro":
+                return self._macro(args)
+            if root in {"/cpi", "/nfp", "/gdp", "/inflation", "/unemployment"}:
+                return self._macro_indicator(root[1:], args)
+            if root == "/fed" and args and args[0].lower() == "funds":
+                return self._macro_indicator("fed_funds", args[1:])
+            if root == "/profile":
+                return self._profile(args)
+            if root == "/doctor":
+                return self._doctor(args)
+            if root == "/setup":
+                return self._setup(args)
+            if root == "/secrets":
+                return self._secrets(args)
+            if root == "/privacy":
+                return self._privacy(args)
+            if root == "/agent":
+                return self._agent(args)
+            if root == "/connector":
+                return self._connector(args)
+            if root == "/plugin":
+                return self._plugin(args)
+            if root == "/cache":
+                return self._cache(args)
             if root == "/watchlist":
                 return self._watchlist(args)
             if root == "/portfolio":
@@ -233,6 +260,8 @@ class CommandRouter:
                 return self._mtf(args)
             if root == "/backtest":
                 return self._backtest(args)
+            if root == "/trading":
+                return self._trading(args)
             if root == "/structure":
                 return self._structure(args)
             if root == "/news":
@@ -262,26 +291,26 @@ class CommandRouter:
             if exc.help_text:
                 message = f"{message}\n\n{exc.help_text}"
             return CommandResult(Panel(message, title="Error", border_style="red"), status="error")
-        except ValueError as exc:
-            return CommandResult(
-                Panel(f"Format command tidak valid: {exc}\nGunakan quote untuk teks panjang.", title="Error"),
-                status="error",
-            )
-        except Exception as exc:  # noqa: BLE001
-            return CommandResult(
-                Panel(
-                    (
-                        f"Unexpected command error: {type(exc).__name__}: {exc}\n\n"
-                        "Command tidak dieksekusi penuh. Gunakan /doctor untuk cek konfigurasi atau coba ulang command."
-                    ),
-                    title="Error",
-                    border_style="red",
-                ),
-                status="error",
-            )
+        except ValueError as exc:
+            return CommandResult(
+                Panel(f"Format command tidak valid: {exc}\nGunakan quote untuk teks panjang.", title="Error"),
+                status="error",
+            )
+        except Exception as exc:  # noqa: BLE001
+            return CommandResult(
+                Panel(
+                    (
+                        f"Unexpected command error: {type(exc).__name__}: {exc}\n\n"
+                        "Command tidak dieksekusi penuh. Gunakan /doctor untuk cek konfigurasi atau coba ulang command."
+                    ),
+                    title="Error",
+                    border_style="red",
+                ),
+                status="error",
+            )
 
     def _help_table(self) -> Table:
-        table = Table(title="FinCLI v0.3.1 Commands", expand=True)
+        table = Table(title="FinCLI v0.4.0 Commands", expand=True)
         table.add_column("Command", style="cyan", no_wrap=True)
         table.add_column("Group", style="magenta")
         table.add_column("Fungsi", style="white")
@@ -290,19 +319,19 @@ class CommandRouter:
             table.add_row(command.name, command.group, command.description, command.example)
         return table
 
-    def _record_history(self, raw: str, result: CommandResult) -> None:
-        normalized = raw.strip().lower()
-        if (
-            not normalized
-            or normalized.startswith("/history")
-            or normalized.startswith("/privacy purge")
-            or normalized.startswith("/secrets clear")
-        ):
-            return
+    def _record_history(self, raw: str, result: CommandResult) -> None:
+        normalized = raw.strip().lower()
+        if (
+            not normalized
+            or normalized.startswith("/history")
+            or normalized.startswith("/privacy purge")
+            or normalized.startswith("/secrets clear")
+        ):
+            return
         try:
             preview = _render_history_preview(result.renderable)
             self.history.record_event(self.session_id, raw, result.status, preview)
-        except FinCLIError:
+        except Exception:
             return
 
     def _history(self, args: list[str]) -> CommandResult:
@@ -362,12 +391,14 @@ class CommandRouter:
         lines = [
             f"AI provider       : {safe['ai_provider']}",
             f"AI model          : {safe['ai_model']}",
-            f"Market provider   : {safe['market_provider']}",
-            f"News provider     : {safe['news_provider']}",
-            f"News priority     : {', '.join(safe.get('news_provider_priority', []))}",
-            f"Timezone          : {safe['timezone']}",
+            f"Market provider   : {safe['market_provider']}",
+            f"News provider     : {safe['news_provider']}",
+            f"News priority     : {', '.join(safe.get('news_provider_priority', []))}",
+            f"Timezone          : {safe['timezone']}",
             f"Default currency  : {safe['default_currency']}",
             f"Cache TTL         : {safe['cache_ttl_seconds']}s",
+            f"Provider timeout  : {safe['provider_timeout_seconds']}s",
+            f"Circuit breaker   : {safe['provider_circuit_breaker_failure_threshold']} failures / {safe['provider_circuit_breaker_cooldown_seconds']}s cooldown",
             f"Theme             : {safe['theme']}",
             "",
             "API key status:",
@@ -407,115 +438,126 @@ class CommandRouter:
         self.ai_provider = AIProviderManager().create(args[0])
         return CommandResult(Panel(f"AI model aktif: {args[0]} / {args[1]}", title="AI Model Updated"))
 
-    def _news_model(self, args: list[str]) -> CommandResult:
-        if len(args) == 0:
-            current = self.config.settings
-            chain = ", ".join(current.news_provider_priority or [current.news_provider])
-            return CommandResult(
-                Panel(
-                    (
-                        f"Market: {current.market_provider}\n"
-                        f"News: {current.news_provider}\n"
-                        f"Fallback priority: {chain}\n\n"
-                        "Commands:\n"
-                        "- /news_model list\n"
-                        "- /news_model search <query>\n"
-                        "- /news_model use <provider>\n"
-                        "- /news_model priority google_news_rss,yfinance,marketaux\n"
-                        "- /news_model key <provider> <api_key> [base_url]"
-                    ),
-                    title="Active Data Provider",
-                )
-            )
-        action = args[0].lower()
-        if action == "list":
-            return CommandResult(_format_news_connectors(self.news_connector_catalog.free_first()[:120], "all"))
-        if action == "search":
-            query = " ".join(args[1:]).strip()
-            if not query:
-                raise CommandError("Format: /news_model search <query>")
-            return CommandResult(_format_news_connectors(self.news_connector_catalog.search(query), query))
-        if action == "priority":
-            if len(args) < 2:
-                raise CommandError("Format: /news_model priority google_news_rss,yfinance,marketaux")
-            providers = [provider.strip().lower() for provider in args[1].split(",") if provider.strip()]
-            self._validate_news_providers(providers)
-            self.config.set_news_provider_priority(providers)
-            return CommandResult(
-                Panel(
-                    f"News fallback priority disimpan: {', '.join(self.config.settings.news_provider_priority)}",
-                    title="News Priority Updated",
-                    border_style="green",
-                )
-            )
-        if action == "use":
-            if len(args) < 2:
-                raise CommandError("Format: /news_model use <provider>")
-            provider = args[1].lower()
-            self._validate_news_providers([provider])
-            current = [item for item in self.config.settings.news_provider_priority if item != provider]
-            self.config.set_news_provider_priority([provider, *current])
-            return CommandResult(
-                Panel(
-                    f"News primary provider: {provider}\nFallback: {', '.join(self.config.settings.news_provider_priority)}",
-                    title="News Provider Updated",
-                    border_style="green",
-                )
-            )
-        if action == "key":
-            if len(args) < 3:
-                raise CommandError("Format: /news_model key <provider> <api_key> [base_url untuk custom]")
-            provider = args[1].lower()
-            env_key = news_connector_secret_key(provider)
-            env_keys = (env_key,) if env_key else _market_provider_secret_keys(provider)
-            if not env_keys:
-                raise CommandError(f"Provider {provider} tidak membutuhkan API key atau tidak dikenal.")
-            save_secret(env_keys[0], args[2])
-            if provider == "custom_news" and len(args) >= 4:
-                save_secret("CUSTOM_NEWS_BASE_URL", args[3])
-            elif provider == "custom" and len(args) >= 4:
-                save_secret("MARKET_DATA_BASE_URL", args[3])
-            if self.market_manager.get(provider) is not None:
-                self.config.set_market_provider_priority([provider, *self._priority_tail(provider)])
-                self.config.set_news_provider(provider)
-                self._refresh_market_service()
-            else:
-                self.config.set_news_provider_priority([provider, *self._news_priority_tail(provider)])
-            self.cache.clear()
-            extra = "\nBase URL custom juga disimpan." if provider in {"custom", "custom_news"} and len(args) >= 4 else ""
-            return CommandResult(
-                Panel(
-                    (
-                        f"API key market/news untuk {provider} disimpan global di ~/.fincli/secrets.env.{extra}\n"
-                        f"Provider news aktif disimpan: {provider}.\n"
-                        "Key tidak ditampilkan di terminal dan dipakai lintas session."
-                    ),
-                    title="News API Key Saved",
-                    border_style="green",
-                )
-            )
-        provider = args[0].lower()
-        if self.market_manager.get(provider) is not None:
-            self.config.set_market_provider(provider)
-            self.config.set_news_provider(provider)
-            self.config.set_market_provider_priority([provider, *self._priority_tail(provider)])
-            self._refresh_market_service()
-            self.cache.clear()
-            return CommandResult(Panel(f"Provider market/news aktif: {provider}", title="Provider Updated"))
-        self._validate_news_providers([provider])
-        self.config.set_news_provider_priority([provider, *self._news_priority_tail(provider)])
-        self.cache.clear()
-        return CommandResult(Panel(f"Provider news aktif: {provider}", title="News Provider Updated"))
+    def _news_model(self, args: list[str]) -> CommandResult:
+        if len(args) == 0:
+            current = self.config.settings
+            chain = ", ".join(current.news_provider_priority or [current.news_provider])
+            return CommandResult(
+                Panel(
+                    (
+                        f"Market: {current.market_provider}\n"
+                        f"News: {current.news_provider}\n"
+                        f"Fallback priority: {chain}\n\n"
+                        "Commands:\n"
+                        "- /news_model list\n"
+                        "- /news_model search <query>\n"
+                        "- /news_model use <provider>\n"
+                        "- /news_model priority google_news_rss,yfinance,marketaux\n"
+                        "- /news_model key <provider> <api_key> [base_url]"
+                    ),
+                    title="Active Data Provider",
+                )
+            )
+        action = args[0].lower()
+        if action == "list":
+            return CommandResult(_format_news_connectors(self.news_connector_catalog.free_first()[:120], "all"))
+        if action == "search":
+            query = " ".join(args[1:]).strip()
+            if not query:
+                raise CommandError("Format: /news_model search <query>")
+            return CommandResult(_format_news_connectors(self.news_connector_catalog.search(query), query))
+        if action == "priority":
+            if len(args) < 2:
+                raise CommandError("Format: /news_model priority google_news_rss,yfinance,marketaux")
+            providers = [provider.strip().lower() for provider in args[1].split(",") if provider.strip()]
+            self._validate_news_providers(providers)
+            self.config.set_news_provider_priority(providers)
+            return CommandResult(
+                Panel(
+                    f"News fallback priority disimpan: {', '.join(self.config.settings.news_provider_priority)}",
+                    title="News Priority Updated",
+                    border_style="green",
+                )
+            )
+        if action == "use":
+            if len(args) < 2:
+                raise CommandError("Format: /news_model use <provider>")
+            provider = args[1].lower()
+            self._validate_news_providers([provider])
+            current = [item for item in self.config.settings.news_provider_priority if item != provider]
+            self.config.set_news_provider_priority([provider, *current])
+            return CommandResult(
+                Panel(
+                    f"News primary provider: {provider}\nFallback: {', '.join(self.config.settings.news_provider_priority)}",
+                    title="News Provider Updated",
+                    border_style="green",
+                )
+            )
+        if action == "key":
+            if len(args) < 3:
+                raise CommandError("Format: /news_model key <provider> <api_key> [base_url untuk custom]")
+            provider = args[1].lower()
+            env_key = news_connector_secret_key(provider)
+            env_keys = (env_key,) if env_key else _market_provider_secret_keys(provider)
+            if not env_keys:
+                raise CommandError(f"Provider {provider} tidak membutuhkan API key atau tidak dikenal.")
+            save_secret(env_keys[0], args[2])
+            if provider == "custom_news" and len(args) >= 4:
+                save_secret("CUSTOM_NEWS_BASE_URL", args[3])
+            elif provider == "custom" and len(args) >= 4:
+                save_secret("MARKET_DATA_BASE_URL", args[3])
+            if self.market_manager.get(provider) is not None:
+                self.config.set_market_provider_priority([provider, *self._priority_tail(provider)])
+                self.config.set_news_provider(provider)
+                self._refresh_market_service()
+            else:
+                self.config.set_news_provider_priority([provider, *self._news_priority_tail(provider)])
+            self.cache.clear()
+            extra = "\nBase URL custom juga disimpan." if provider in {"custom", "custom_news"} and len(args) >= 4 else ""
+            return CommandResult(
+                Panel(
+                    (
+                        f"API key market/news untuk {provider} disimpan global di ~/.fincli/secrets.env.{extra}\n"
+                        f"Provider news aktif disimpan: {provider}.\n"
+                        "Key tidak ditampilkan di terminal dan dipakai lintas session."
+                    ),
+                    title="News API Key Saved",
+                    border_style="green",
+                )
+            )
+        provider = args[0].lower()
+        if self.market_manager.get(provider) is not None:
+            self.config.set_market_provider(provider)
+            self.config.set_news_provider(provider)
+            self.config.set_market_provider_priority([provider, *self._priority_tail(provider)])
+            self._refresh_market_service()
+            self.cache.clear()
+            return CommandResult(Panel(f"Provider market/news aktif: {provider}", title="Provider Updated"))
+        self._validate_news_providers([provider])
+        self.config.set_news_provider_priority([provider, *self._news_priority_tail(provider)])
+        self.cache.clear()
+        return CommandResult(Panel(f"Provider news aktif: {provider}", title="News Provider Updated"))
 
     def _provider(self, args: list[str]) -> CommandResult:
         if args and args[0].lower() == "list":
             return CommandResult(_format_provider_list())
-        if args and args[0].lower() in {"entitlement", "entitlements"}:
-            return CommandResult(_format_provider_entitlements(self.market_manager.entitlements()))
-        if args and args[0].lower() == "metrics":
-            return CommandResult(_format_provider_metrics(self.market_service))
+        if args and args[0].lower() in {"entitlement", "entitlements"}:
+            return CommandResult(_format_provider_entitlements(self.market_manager.entitlements()))
+        if args and args[0].lower() == "metrics":
+            return CommandResult(_format_provider_metrics(self.market_service))
         if args and args[0].lower() == "key" and len(args) >= 2 and args[1].lower() == "status":
             return CommandResult(_format_provider_key_status(self.market_manager))
+        if args and args[0].lower() in {"insider", "insiders"}:
+            if len(args) < 2:
+                raise CommandError("Format: /provider insider <symbol>")
+            provider = self.market_manager.create("finnhub")
+            rows = self._run_async(provider.insider_transactions(args[1].upper()))
+            return CommandResult(_format_insider_transactions(args[1].upper(), rows))
+        if args and args[0].lower() == "ipo":
+            start, end, _, _ = _parse_calendar_args(args[1:] or ["week"])
+            provider = self.market_manager.create("finnhub")
+            rows = self._run_async(provider.ipo_calendar(start, end))
+            return CommandResult(_format_ipo_calendar(rows, start, end))
         if args and args[0].lower() == "use":
             if len(args) < 2:
                 raise CommandError("Format: /provider use <provider>")
@@ -554,195 +596,314 @@ class CommandRouter:
             return CommandResult(_format_quote(quote))
         raise CommandError(
             "Format: /provider status, /provider list, /provider entitlement, /provider key status, /provider use <provider>, "
-            "/provider priority finnhub,yfinance, atau /provider test [provider] <symbol>"
+            "/provider priority finnhub,yfinance, /provider insider <symbol>, /provider ipo [week|from to], "
+            "atau /provider test [provider] <symbol>"
         )
 
-    def _symbol(self, args: list[str]) -> CommandResult:
-        if not args:
-            raise CommandError("Format: /symbol <query> atau /symbol normalize <symbol>")
-        action = args[0].lower()
-        if action in {"normalize", "norm"}:
+    def _symbol(self, args: list[str]) -> CommandResult:
+        if not args:
+            raise CommandError("Format: /symbol search <query>, /symbol resolve <symbol> [--asset <class>], atau /symbol normalize <symbol>")
+        action = args[0].lower()
+        if action in {"resolve", "normalize", "norm"}:
+            if len(args) < 2:
+                raise CommandError("Format: /symbol resolve <symbol> [--asset <class>]")
+            asset_class = _extract_option_value(args[2:], "--asset")
+            return CommandResult(_format_symbol_matrix(args[1], self.symbol_resolver, asset_class=asset_class))
+        if action == "search":
             if len(args) < 2:
-                raise CommandError("Format: /symbol normalize <symbol>")
-            return CommandResult(_format_symbol_matrix(args[1]))
-        query = " ".join(args)
-        results = search_symbol_catalog(query)
-        return CommandResult(_format_symbol_search(query, results))
-
-    def _research(self, args: list[str]) -> CommandResult:
-        if not args:
-            raise CommandError("Format: /research <symbol> [--deep|--report] [timeframe] [--export <md|json> <path>]")
-        symbol = args[0].upper()
-        export_format: str | None = None
-        export_target: str | None = None
-        if "--export" in args:
-            export_index = args.index("--export")
-            if len(args) <= export_index + 2:
-                raise CommandError("Format export: /research <symbol> --report --export <md|json> <path>")
-            export_format = args[export_index + 1]
-            export_target = args[export_index + 2]
-        flags = {arg.lower() for arg in args[1:] if arg.startswith("--")}
-        if "--report" in flags:
-            mode = "report"
-        elif "--deep" in flags:
-            mode = "deep"
-        else:
-            mode = "quick"
-        ignored: set[int] = set()
-        if "--export" in args:
-            export_index = args.index("--export")
-            ignored.update({export_index, export_index + 1, export_index + 2})
-        timeframe = next((arg for index, arg in enumerate(args[1:], start=1) if index not in ignored and not arg.startswith("--")), "1d")
-        engine = ResearchEngine(self.market_service, self.ai_provider, self.config.settings.ai_model)
-        brief = self._run_async(engine.build(symbol, timeframe=timeframe, mode=mode))
-        if export_format and export_target:
-            written = write_research_report(brief, export_format, export_target)
-            return CommandResult(Panel(f"Research export selesai: {written}", title="Research Export", border_style="green"))
-        return CommandResult(format_research_brief(brief))
-
-    def _macro(self, args: list[str]) -> CommandResult:
-        query = " ".join(args).strip()
-        rows = self.macro_data.indicators(query)
-        return CommandResult(_format_macro_dashboard(query or "global", rows))
-
-    def _profile(self, args: list[str]) -> CommandResult:
-        if not args:
-            return CommandResult(_format_user_profile(self.user_profiles.get()))
-        action = args[0].lower()
-        if action == "set":
-            if len(args) < 6:
-                raise CommandError('Format: /profile set "Nama" <equity> <currency> <leverage> <years>')
-            profile = self.user_profiles.save(args[1], float(args[2]), args[3], args[4], float(args[5]))
-            return CommandResult(_format_user_profile(profile))
-        if action in {"clear", "delete", "reset"}:
-            self.user_profiles.clear()
-            return CommandResult(Panel("Profile lokal dihapus.", title="Profile", border_style="yellow"))
-        raise CommandError('Format: /profile, /profile set "Nama" <equity> <currency> <leverage> <years>, /profile clear')
-
-    def _doctor(self, args: list[str]) -> CommandResult:
-        table = Table(title="FinCLI Doctor", expand=True)
-        table.add_column("Check", style="cyan", no_wrap=True)
-        table.add_column("Status")
-        table.add_column("Detail", overflow="fold")
-        table.add_row("Version", "ok", "FinCLI v0.3.1 command surface loaded.")
-        table.add_row("Database", "ok", str(self.db.db_file))
-        table.add_row("Market Provider", "ok", ", ".join(provider.name for provider in self.market_service.providers))
-        profile = self.user_profiles.get()
-        table.add_row("Profile", "ok" if profile else "missing", profile.gameplay if profile else "Run /profile set ...")
-        table.add_row("AI Provider", "configured", f"{self.config.settings.ai_provider} / {self.config.settings.ai_model}")
-        table.caption = "Doctor checks local wiring only; provider entitlement still depends on your API key/account."
-        return CommandResult(table)
-
-    def _setup(self, args: list[str]) -> CommandResult:
-        return CommandResult(
-            Panel(
-                "\n".join(
-                    [
-                        "Recommended setup:",
-                        '1. /profile set "Nama" <equity> <currency> <leverage> <years>',
-                        "2. /ai_model key <provider> <api_key>",
-                        "3. /news_model key <provider> <api_key>",
-                        "4. /provider priority yfinance,alphavantage,twelvedata,finnhub",
-                        "5. /research AAPL --quick",
-                        "6. /analyze XAUUSD 1d",
-                    ]
-                ),
-                title="FinCLI Setup",
-                border_style="cyan",
-            )
-        )
-
-    def _secrets(self, args: list[str]) -> CommandResult:
-        action = args[0].lower() if args else "status"
-        if action == "status":
-            return CommandResult(_format_secrets_status(read_secrets()))
-        if action == "clear":
-            cleared = clear_secrets()
-            return CommandResult(
-                Panel(
-                    f"{cleared} local secret(s) cleared from ~/.fincli/secrets.env. Current process keys from that store were removed.",
-                    title="Secrets Cleared",
-                    border_style="yellow",
-                )
-            )
-        raise CommandError("Format: /secrets status atau /secrets clear")
-
-    def _privacy(self, args: list[str]) -> CommandResult:
-        action = args[0].lower() if args else "status"
-        if action == "status":
-            stats = self.market_cache.stats()
-            return CommandResult(
-                Panel(
-                    "\n".join(
-                        [
-                            f"Secrets stored       : {len(read_secrets())}",
-                            f"Session events       : {len(self.history.get_events(self.session_id))}",
-                            f"Persistent cache rows: {stats['total']}",
-                            "Purge scope          : secrets + current session history + runtime/persistent cache",
-                            "Portfolio, journal, alerts, and profile are not deleted by /privacy purge.",
-                        ]
-                    ),
-                    title="Privacy Status",
-                    border_style="cyan",
-                )
-            )
-        if action == "purge":
-            secrets_cleared = clear_secrets()
-            self.history.clear_events(self.session_id)
-            self.cache.clear()
-            cache_cleared = self.market_cache.clear()
-            return CommandResult(
-                Panel(
-                    (
-                        f"Privacy state purged.\n"
-                        f"- secrets cleared: {secrets_cleared}\n"
-                        f"- current session history cleared\n"
-                        f"- runtime cache cleared\n"
-                        f"- persistent market cache rows cleared: {cache_cleared}\n\n"
-                        "Portfolio, journal, alerts, and profile were kept."
-                    ),
-                    title="Privacy Purge",
-                    border_style="yellow",
-                )
-            )
-        raise CommandError("Format: /privacy status atau /privacy purge")
-
-    def _agent(self, args: list[str]) -> CommandResult:
-        action = args[0].lower() if args else "list"
-        if action in {"list", "ls"}:
-            category = args[1].lower() if len(args) >= 2 else ""
-            agents = self.agent_registry.by_category(category) if category else list(self.agent_registry.all())
-            return CommandResult(_format_agents(agents, category or "all"))
-        if action == "show":
-            if len(args) < 2:
-                raise CommandError("Format: /agent show <slug>")
-            agent = self.agent_registry.get(args[1])
-            if agent is None:
-                raise CommandError(f"Agent tidak ditemukan: {args[1]}")
-            return CommandResult(_format_agent(agent))
-        raise CommandError("Format: /agent list [category] atau /agent show <slug>")
-
-    def _connector(self, args: list[str]) -> CommandResult:
-        action = args[0].lower() if args else "list"
-        if action in {"list", "ls"}:
-            category = args[1].lower() if len(args) >= 2 else ""
-            connectors = self.connector_catalog.by_category(category) if category else list(self.connector_catalog.all())
-            return CommandResult(_format_connectors(connectors, category or "all"))
-        if action in {"search", "find"}:
-            if len(args) < 2:
-                raise CommandError("Format: /connector search <query>")
-            query = " ".join(args[1:])
-            return CommandResult(_format_connectors(self.connector_catalog.find(query), query))
-        raise CommandError("Format: /connector list [category] atau /connector search <query>")
-
-    def _plugin(self, args: list[str]) -> CommandResult:
-        action = args[0].lower() if args else "list"
-        if action in {"list", "ls", "status"}:
-            plugins = PluginLoader().discover()
-            return CommandResult(_format_plugins(plugins, status_only=action == "status"))
-        raise CommandError("Format: /plugin list atau /plugin status")
-
-    def _cache(self, args: list[str]) -> CommandResult:
+                raise CommandError("Format: /symbol search <query>")
+            query = " ".join(args[1:])
+        else:
+            query = " ".join(args)
+        results = search_symbol_catalog(query)
+        return CommandResult(_format_symbol_search(query, results))
+
+    def _research(self, args: list[str]) -> CommandResult:
+        if not args:
+            raise CommandError("Format: /research <symbol> [--deep|--report] [timeframe] [--export <md|json> <path>]")
+        symbol = args[0].upper()
+        export_format: str | None = None
+        export_target: str | None = None
+        if "--export" in args:
+            export_index = args.index("--export")
+            if len(args) <= export_index + 2:
+                raise CommandError("Format export: /research <symbol> --report --export <md|json> <path>")
+            export_format = args[export_index + 1]
+            export_target = args[export_index + 2]
+        flags = {arg.lower() for arg in args[1:] if arg.startswith("--")}
+        if "--report" in flags:
+            mode = "report"
+        elif "--deep" in flags:
+            mode = "deep"
+        else:
+            mode = "quick"
+        ignored: set[int] = set()
+        if "--export" in args:
+            export_index = args.index("--export")
+            ignored.update({export_index, export_index + 1, export_index + 2})
+        timeframe = next((arg for index, arg in enumerate(args[1:], start=1) if index not in ignored and not arg.startswith("--")), "1d")
+        engine = ResearchEngine(self.market_service, self.ai_provider, self.config.settings.ai_model)
+        brief = self._run_async(engine.build(symbol, timeframe=timeframe, mode=mode))
+        if export_format and export_target:
+            written = write_research_report(brief, export_format, export_target)
+            return CommandResult(Panel(f"Research export selesai: {written}", title="Research Export", border_style="green"))
+        return CommandResult(format_research_brief(brief))
+
+    def _macro(self, args: list[str]) -> CommandResult:
+        query = " ".join(args).strip()
+        rows = self.macro_data.indicators(query)
+        return CommandResult(_format_macro_dashboard(query or "global", rows))
+
+    def _macro_indicator(self, indicator: str, args: list[str]) -> CommandResult:
+        if indicator == "gdp" and args[:2] and " ".join(args[:2]).lower() == "per capita":
+            indicator = "gdp_per_capita"
+            args = args[2:]
+        region = args[0] if args else "us"
+        try:
+            rows = self.macro_data.alpha_vantage_indicator(indicator, region)
+        except FinCLIError as exc:
+            rows = [_macro_error_row(indicator, region, exc)]
+        return CommandResult(_format_macro_indicator(indicator, region, rows))
+
+    def _profile(self, args: list[str]) -> CommandResult:
+        if not args:
+            return CommandResult(_format_user_profile(self.user_profiles.get()))
+        action = args[0].lower()
+        if action == "set":
+            if len(args) < 6:
+                raise CommandError('Format: /profile set "Nama" <equity> <currency> <leverage> <years>')
+            profile = self.user_profiles.save(args[1], float(args[2]), args[3], args[4], float(args[5]))
+            return CommandResult(_format_user_profile(profile))
+        if action in {"clear", "delete", "reset"}:
+            self.user_profiles.clear()
+            return CommandResult(Panel("Profile lokal dihapus.", title="Profile", border_style="yellow"))
+        raise CommandError('Format: /profile, /profile set "Nama" <equity> <currency> <leverage> <years>, /profile clear')
+
+    def _doctor(self, args: list[str]) -> CommandResult:
+        full = bool(args and args[0].lower() in {"full", "deep"})
+        live = "--live" in {arg.lower() for arg in args}
+        live_symbol = _doctor_live_symbol(args)
+        table = Table(title="FinCLI Doctor Full" if full else "FinCLI Doctor", expand=True)
+        table.add_column("Check", style="cyan", no_wrap=True)
+        table.add_column("Status")
+        table.add_column("Detail", overflow="fold")
+        table.add_row("Version", "ok", "FinCLI v0.4.0 command surface loaded.")
+        for check in check_runtime_environment():
+            style = "green" if check.status == "ok" else "yellow" if check.status in {"warning", "info"} else "red"
+            table.add_row(check.name, f"[{style}]{check.status}[/]", check.detail)
+        table.add_row("Database", "ok", str(self.db.db_file))
+        table.add_row("Market Provider", "ok", ", ".join(provider.name for provider in self.market_service.providers))
+        table.add_row("Provider Timeout", "ok", f"{self.config.settings.provider_timeout_seconds}s per provider call")
+        table.add_row(
+            "Circuit Breaker",
+            "ok",
+            (
+                f"{self.config.settings.provider_circuit_breaker_failure_threshold} failures -> "
+                f"{self.config.settings.provider_circuit_breaker_cooldown_seconds}s cooldown"
+            ),
+        )
+        profile = self.user_profiles.get()
+        table.add_row("Profile", "ok" if profile else "missing", profile.gameplay if profile else "Run /profile set ...")
+        table.add_row("AI Provider", "configured", f"{self.config.settings.ai_provider} / {self.config.settings.ai_model}")
+        if full:
+            for name, status, detail in self._doctor_full_checks():
+                style = "green" if status == "ok" else "yellow" if status in {"warning", "info"} else "red"
+                table.add_row(name, f"[{style}]{status}[/]", detail)
+            if live:
+                for name, status, detail in self._doctor_live_checks(live_symbol):
+                    style = "green" if status == "ok" else "yellow" if status in {"warning", "info"} else "red"
+                    table.add_row(name, f"[{style}]{status}[/]", detail)
+        table.caption = (
+            "Doctor full checks local wiring, command coverage, database/cache, and provider configuration. "
+            "Use /doctor full --live [SYMBOL] for optional live quote verification. "
+            "Provider entitlement still depends on API key/account plan."
+        )
+        return CommandResult(table)
+
+    def _doctor_full_checks(self) -> list[tuple[str, str, str]]:
+        checks: list[tuple[str, str, str]] = []
+        try:
+            tables = self.db.query("SELECT name FROM sqlite_master WHERE type = 'table'")
+            checks.append(("Database Schema", "ok", f"{len(tables)} table(s) available"))
+        except FinCLIError as exc:
+            checks.append(("Database Schema", "error", str(exc)))
+
+        try:
+            stats = self.market_cache.stats()
+            checks.append(("Market Cache", "ok", ", ".join(f"{key}={value}" for key, value in stats.items())))
+        except FinCLIError as exc:
+            checks.append(("Market Cache", "error", str(exc)))
+
+        key_rows = self.market_manager.key_status()
+        missing_keys = [row["provider"] for row in key_rows if row["status"] == "not set"]
+        configured_keys = [row["provider"] for row in key_rows if row["status"] not in {"not set", "not required"}]
+        checks.append(
+            (
+                "Market API Keys",
+                "warning" if missing_keys else "ok",
+                f"configured={len(configured_keys)}; missing={', '.join(missing_keys) if missing_keys else 'none'}",
+            )
+        )
+
+        for provider in self.market_service.providers:
+            provider_name = getattr(provider, "name", "unknown")
+            try:
+                status = self._run_async(provider.status())
+                checks.append((f"Provider:{provider_name}", "ok" if status.status in {"ok", "configured", "fallback"} else "warning", status.message))
+            except Exception as exc:  # noqa: BLE001
+                checks.append((f"Provider:{provider_name}", "error", str(exc)))
+
+        registry_roots = {command.name.split()[0] for command in self.registry.all()}
+        router_roots = _router_roots()
+        hidden = sorted(router_roots - registry_roots)
+        stale = sorted(registry_roots - router_roots)
+        if hidden or stale:
+            checks.append(
+                (
+                    "Command Coverage",
+                    "warning",
+                    f"hidden={', '.join(hidden) if hidden else 'none'}; stale={', '.join(stale) if stale else 'none'}",
+                )
+            )
+        else:
+            checks.append(("Command Coverage", "ok", f"{len(registry_roots)} registry root command(s) covered by router"))
+
+        metric_snapshot = self.market_service.provider_metrics_snapshot()
+        checks.append(("Provider Metrics", "ok", f"session_providers={len(metric_snapshot)}; persistent_store=enabled"))
+        checks.append(("Capability Matrix", "ok", capability_summary()))
+        for capability in capability_rows():
+            checks.append(
+                (
+                    f"Capability:{capability.command}",
+                    "ok",
+                    f"needs={', '.join(capability.needs)}; {capability.note}",
+                )
+            )
+        return checks
+
+    def _doctor_live_checks(self, symbol: str) -> list[tuple[str, str, str]]:
+        try:
+            quote = self._run_async(asyncio.wait_for(self.market_service.quote(symbol), self.config.settings.provider_timeout_seconds))
+        except Exception as exc:  # noqa: BLE001
+            return [("Live Quote Test", "error", f"{symbol}: {type(exc).__name__}: {exc}")]
+        return [
+            (
+                "Live Quote Test",
+                "ok" if quote.price is not None else "warning",
+                f"{quote.symbol} {quote.price if quote.price is not None else 'N/A'} {quote.currency}; provider={quote.provider}; status={quote.status}",
+            )
+        ]
+
+    def _setup(self, args: list[str]) -> CommandResult:
+        return CommandResult(
+            Panel(
+                "\n".join(
+                    [
+                        "Recommended setup:",
+                        '1. /profile set "Nama" <equity> <currency> <leverage> <years>',
+                        "2. /ai_model key <provider> <api_key>",
+                        "3. /news_model key <provider> <api_key>",
+                        "4. /provider priority yfinance,alphavantage,twelvedata,finnhub",
+                        "5. /research AAPL --quick",
+                        "6. /analyze XAUUSD 1d",
+                    ]
+                ),
+                title="FinCLI Setup",
+                border_style="cyan",
+            )
+        )
+
+    def _secrets(self, args: list[str]) -> CommandResult:
+        action = args[0].lower() if args else "status"
+        if action == "status":
+            return CommandResult(_format_secrets_status(read_secrets()))
+        if action == "clear":
+            cleared = clear_secrets()
+            return CommandResult(
+                Panel(
+                    f"{cleared} local secret(s) cleared from ~/.fincli/secrets.env. Current process keys from that store were removed.",
+                    title="Secrets Cleared",
+                    border_style="yellow",
+                )
+            )
+        raise CommandError("Format: /secrets status atau /secrets clear")
+
+    def _privacy(self, args: list[str]) -> CommandResult:
+        action = args[0].lower() if args else "status"
+        if action == "status":
+            stats = self.market_cache.stats()
+            return CommandResult(
+                Panel(
+                    "\n".join(
+                        [
+                            f"Secrets stored       : {len(read_secrets())}",
+                            f"Session events       : {len(self.history.get_events(self.session_id))}",
+                            f"Persistent cache rows: {stats['total']}",
+                            "Purge scope          : secrets + current session history + runtime/persistent cache",
+                            "Portfolio, journal, alerts, and profile are not deleted by /privacy purge.",
+                        ]
+                    ),
+                    title="Privacy Status",
+                    border_style="cyan",
+                )
+            )
+        if action == "purge":
+            secrets_cleared = clear_secrets()
+            self.history.clear_events(self.session_id)
+            self.cache.clear()
+            cache_cleared = self.market_cache.clear()
+            return CommandResult(
+                Panel(
+                    (
+                        f"Privacy state purged.\n"
+                        f"- secrets cleared: {secrets_cleared}\n"
+                        f"- current session history cleared\n"
+                        f"- runtime cache cleared\n"
+                        f"- persistent market cache rows cleared: {cache_cleared}\n\n"
+                        "Portfolio, journal, alerts, and profile were kept."
+                    ),
+                    title="Privacy Purge",
+                    border_style="yellow",
+                )
+            )
+        raise CommandError("Format: /privacy status atau /privacy purge")
+
+    def _agent(self, args: list[str]) -> CommandResult:
+        action = args[0].lower() if args else "list"
+        if action in {"list", "ls"}:
+            category = args[1].lower() if len(args) >= 2 else ""
+            agents = self.agent_registry.by_category(category) if category else list(self.agent_registry.all())
+            return CommandResult(_format_agents(agents, category or "all"))
+        if action == "show":
+            if len(args) < 2:
+                raise CommandError("Format: /agent show <slug>")
+            agent = self.agent_registry.get(args[1])
+            if agent is None:
+                raise CommandError(f"Agent tidak ditemukan: {args[1]}")
+            return CommandResult(_format_agent(agent))
+        raise CommandError("Format: /agent list [category] atau /agent show <slug>")
+
+    def _connector(self, args: list[str]) -> CommandResult:
+        action = args[0].lower() if args else "list"
+        if action in {"list", "ls"}:
+            category = args[1].lower() if len(args) >= 2 else ""
+            connectors = self.connector_catalog.by_category(category) if category else list(self.connector_catalog.all())
+            return CommandResult(_format_connectors(connectors, category or "all"))
+        if action in {"search", "find"}:
+            if len(args) < 2:
+                raise CommandError("Format: /connector search <query>")
+            query = " ".join(args[1:])
+            return CommandResult(_format_connectors(self.connector_catalog.find(query), query))
+        raise CommandError("Format: /connector list [category] atau /connector search <query>")
+
+    def _plugin(self, args: list[str]) -> CommandResult:
+        action = args[0].lower() if args else "list"
+        if action in {"list", "ls", "status"}:
+            plugins = PluginLoader().discover()
+            return CommandResult(_format_plugins(plugins, status_only=action == "status"))
+        raise CommandError("Format: /plugin list atau /plugin status")
+
+    def _cache(self, args: list[str]) -> CommandResult:
         if args and args[0].lower() == "stats":
             stats = self.market_cache.stats()
             lines = [
@@ -830,11 +991,11 @@ class CommandRouter:
                 )
             return CommandResult(table)
 
-        action = args[0].lower()
-        if action == "risk":
-            return CommandResult(_format_portfolio_risk(self._portfolio_risk_report()))
-        if action == "performance":
-            return CommandResult(self._portfolio_performance_table())
+        action = args[0].lower()
+        if action == "risk":
+            return CommandResult(_format_portfolio_risk(self._portfolio_risk_report()))
+        if action == "performance":
+            return CommandResult(self._portfolio_performance_table())
         if action == "add" and len(args) >= 4:
             try:
                 quantity = float(args[2])
@@ -846,10 +1007,10 @@ class CommandRouter:
         if action == "remove" and len(args) >= 2:
             self.portfolio.remove(args[1])
             return CommandResult(Panel(f"Posisi {args[1].upper()} dihapus.", title="Portfolio"))
-        raise CommandError(
-            "Format: /portfolio, /portfolio risk, /portfolio performance, /portfolio add <symbol> <qty> <avg_price>, "
-            "/portfolio remove <symbol>"
-        )
+        raise CommandError(
+            "Format: /portfolio, /portfolio risk, /portfolio performance, /portfolio add <symbol> <qty> <avg_price>, "
+            "/portfolio remove <symbol>"
+        )
 
     def _tx(self, args: list[str]) -> CommandResult:
         if not args or args[0].lower() == "list":
@@ -1010,6 +1171,34 @@ class CommandRouter:
         result = run_backtest(symbol, candles, strategy=strategy, interval=interval)
         return CommandResult(_format_backtest(result))
 
+    def _trading(self, args: list[str]) -> CommandResult:
+        if not args:
+            return CommandResult(_format_trading_overview(self.realtime_connector_catalog, self.broker_catalog))
+        action = args[0].lower()
+        if action in {"realtime", "feeds", "feed"}:
+            return CommandResult(_format_realtime_connectors(self.realtime_connector_catalog.all()))
+        if action in {"brokers", "broker"}:
+            return CommandResult(_format_brokers(self.broker_catalog.all()))
+        if action == "paper":
+            return self._trading_paper(args[1:])
+        raise CommandError("Format: /trading, /trading realtime, /trading brokers, /trading paper buy|sell <symbol> <qty> <market|limit> [price]")
+
+    def _trading_paper(self, args: list[str]) -> CommandResult:
+        if not args or args[0].lower() in {"orders", "list"}:
+            return CommandResult(_format_paper_orders(self.paper_trading.list_orders()))
+        if len(args) < 4:
+            raise CommandError("Format: /trading paper <buy|sell> <symbol> <qty> <market|limit> [price]")
+        side = args[0].lower()
+        symbol = args[1].upper()
+        try:
+            quantity = float(args[2])
+            price = float(args[4]) if len(args) >= 5 else None
+        except ValueError as exc:
+            raise CommandError("Quantity dan price paper order harus angka.") from exc
+        order_type = args[3].lower()
+        order = self.paper_trading.place_order(side, symbol, quantity, order_type, price=price)
+        return CommandResult(_format_paper_order(order))
+
     def _market(self, args: list[str]) -> CommandResult:
         if not args:
             raise CommandError("Format: /market <symbol> [interval]")
@@ -1029,19 +1218,19 @@ class CommandRouter:
         structure = analyze_market_structure(candles)
         return CommandResult(_format_structure(symbol, interval, structure))
 
-    def _news(self, args: list[str]) -> CommandResult:
-        if not args:
-            raise CommandError("Format: /news <symbol> [1d-30d]")
-        symbol = args[0].upper()
-        lookback_days = _parse_news_lookback(args[1:]) if len(args) > 1 else None
-        desk = self._run_async(
-            NewsAggregator(
-                self.market_service,
-                self.news_connectors,
-                self.config.settings.news_provider_priority,
-            ).latest(symbol, limit=12, lookback_days=lookback_days)
-        )
-        return CommandResult(_format_news_desk(desk))
+    def _news(self, args: list[str]) -> CommandResult:
+        if not args:
+            raise CommandError("Format: /news <symbol> [1d-30d]")
+        symbol = args[0].upper()
+        lookback_days = _parse_news_lookback(args[1:]) if len(args) > 1 else None
+        desk = self._run_async(
+            NewsAggregator(
+                self.market_service,
+                self.news_connectors,
+                self.config.settings.news_provider_priority,
+            ).latest(symbol, limit=12, lookback_days=lookback_days)
+        )
+        return CommandResult(_format_news_desk(desk))
 
     def _fundamentals(self, args: list[str]) -> CommandResult:
         if not args:
@@ -1112,22 +1301,22 @@ class CommandRouter:
         candles = self._run_async(self.market_service.history(symbol, period="6mo", interval=timeframe))
         if not candles:
             raise CommandError(f"Data market kosong untuk {symbol}.")
-        technical = summarize_technical_indicators(candles)
-        structure = analyze_market_structure(candles)
-        news_context = self._analysis_context(symbol)
-        gameplay_context = format_gameplay_context(self.user_profiles.get(), symbol)
-        grounding_context = self._ai_grounding_context(symbol, timeframe)
-        prompt = build_market_analysis_prompt(
-            symbol,
-            timeframe,
-            candles,
-            technical,
-            structure,
-            news_context,
-            gameplay_context,
-            grounding_context=grounding_context,
-        )
-        request = AIRequest(prompt=prompt, model=self.config.settings.ai_model)
+        technical = summarize_technical_indicators(candles)
+        structure = analyze_market_structure(candles)
+        news_context = self._analysis_context(symbol)
+        gameplay_context = format_gameplay_context(self.user_profiles.get(), symbol)
+        grounding_context = self._ai_grounding_context(symbol, timeframe)
+        prompt = build_market_analysis_prompt(
+            symbol,
+            timeframe,
+            candles,
+            technical,
+            structure,
+            news_context,
+            gameplay_context,
+            grounding_context=grounding_context,
+        )
+        request = AIRequest(prompt=prompt, model=self.config.settings.ai_model)
         response = self._run_async(self.ai_provider.complete(request))
         if not isinstance(response, AIResponse):
             raise CommandError("AI provider mengembalikan data tidak valid.")
@@ -1178,16 +1367,16 @@ class CommandRouter:
     def _calendar(self, args: list[str]) -> CommandResult:
         if args and args[0].lower() == "export":
             return self._calendar_export(args[1:])
-        start, end, country, impact = _parse_calendar_args(args)
-        service = EconomicCalendarService(api_key=os.getenv("FINNHUB_API_KEY"))
-        source = "finnhub"
-        note = "Aktual dari provider Finnhub."
-        try:
-            events = self._run_async(service.events(start, end))
-        except FinCLIError as exc:
-            events, source, note = self._calendar_public_or_static_fallback(start, end, exc)
-        events = filter_events(events, country=country, impact=impact)
-        return CommandResult(_format_calendar(events, start, end, source, note))
+        start, end, country, impact = _parse_calendar_args(args)
+        service = EconomicCalendarService(api_key=os.getenv("FINNHUB_API_KEY"))
+        source = "finnhub"
+        note = "Aktual dari provider Finnhub."
+        try:
+            events = self._run_async(service.events(start, end))
+        except FinCLIError as exc:
+            events, source, note = self._calendar_public_or_static_fallback(start, end, exc)
+        events = filter_events(events, country=country, impact=impact)
+        return CommandResult(_format_calendar(events, start, end, source, note))
 
     def _calendar_export(self, args: list[str]) -> CommandResult:
         if len(args) < 2:
@@ -1195,37 +1384,37 @@ class CommandRouter:
         export_format = args[0].lower()
         target = args[1]
         start, end, country, impact = _parse_calendar_args(args[2:])
-        service = EconomicCalendarService(api_key=os.getenv("FINNHUB_API_KEY"))
-        try:
-            events = self._run_async(service.events(start, end))
-        except FinCLIError as exc:
-            events, _, _ = self._calendar_public_or_static_fallback(start, end, exc)
-        events = filter_events(events, country=country, impact=impact)
-        written = export_rows(economic_event_rows(events), export_format, target)
-        return CommandResult(Panel(f"Calendar export selesai: {written}", title="Calendar Export", border_style="green"))
-
-    def _calendar_public_or_static_fallback(
-        self, start: date, end: date, provider_error: FinCLIError
-    ) -> tuple[list[EconomicEvent], str, str]:
-        if not os.getenv("FINNHUB_API_KEY"):
-            return fallback_events(start, end), "fallback", _calendar_fallback_note(provider_error, False)
-        try:
-            events = self._run_async(PublicEconomicCalendarService().events(start, end))
-            if events:
-                return (
-                    events,
-                    "public",
-                    (
-                        "Finnhub calendar unavailable for the current key, plan, or rate limit. "
-                        "Using public economic calendar fallback; verify critical events with official sources."
-                    ),
-                )
-        except FinCLIError as public_error:
-            note = _calendar_static_fallback_note(provider_error, public_error)
-            return fallback_events(start, end), "fallback", note
-        return fallback_events(start, end), "fallback", _calendar_static_fallback_note(provider_error, None)
-
-    def _run_async(self, awaitable: Any) -> Any:
+        service = EconomicCalendarService(api_key=os.getenv("FINNHUB_API_KEY"))
+        try:
+            events = self._run_async(service.events(start, end))
+        except FinCLIError as exc:
+            events, _, _ = self._calendar_public_or_static_fallback(start, end, exc)
+        events = filter_events(events, country=country, impact=impact)
+        written = export_rows(economic_event_rows(events), export_format, target)
+        return CommandResult(Panel(f"Calendar export selesai: {written}", title="Calendar Export", border_style="green"))
+
+    def _calendar_public_or_static_fallback(
+        self, start: date, end: date, provider_error: FinCLIError
+    ) -> tuple[list[EconomicEvent], str, str]:
+        if not os.getenv("FINNHUB_API_KEY"):
+            return fallback_events(start, end), "fallback", _calendar_fallback_note(provider_error, False)
+        try:
+            events = self._run_async(PublicEconomicCalendarService().events(start, end))
+            if events:
+                return (
+                    events,
+                    "public",
+                    (
+                        "Finnhub calendar unavailable for the current key, plan, or rate limit. "
+                        "Using public economic calendar fallback; verify critical events with official sources."
+                    ),
+                )
+        except FinCLIError as public_error:
+            note = _calendar_static_fallback_note(provider_error, public_error)
+            return fallback_events(start, end), "fallback", note
+        return fallback_events(start, end), "fallback", _calendar_static_fallback_note(provider_error, None)
+
+    def _run_async(self, awaitable: Any) -> Any:
         try:
             asyncio.get_running_loop()
         except RuntimeError:
@@ -1253,26 +1442,26 @@ class CommandRouter:
         except (TypeError, ValueError, KeyError):
             return None, None, None
 
-    def _portfolio_performance_table(self) -> Table:
-        risk = self._portfolio_risk_report()
-
-        table = Table(title="Portfolio Performance", expand=True)
-        table.add_column("Metric", style="cyan")
-        table.add_column("Value", justify="right")
-        table.add_row("Cost Basis", _fmt(risk.total_cost_basis))
-        table.add_row("Market Value", _fmt(risk.total_market_value))
-        table.add_row("Unrealized PnL", _fmt(risk.unrealized_pnl))
-        table.add_row("Realized PnL", _fmt(risk.realized_pnl))
-        table.add_row("Total PnL", _fmt(risk.total_pnl))
-        table.add_row("Health Score", f"{risk.health.score}/100 ({risk.health.label})")
-        return table
-
-    def _portfolio_risk_report(self) -> PortfolioRiskReport:
-        positions = self.portfolio.list()
-        values: dict[str, tuple[float | None, float | None, float | None]] = {}
-        for row in positions:
-            values[str(row["symbol"]).upper()] = self._portfolio_market_values(row)
-        return build_portfolio_risk(positions, values, self.transactions.realized_pnl_total(), profile=self.user_profiles.get())
+    def _portfolio_performance_table(self) -> Table:
+        risk = self._portfolio_risk_report()
+
+        table = Table(title="Portfolio Performance", expand=True)
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", justify="right")
+        table.add_row("Cost Basis", _fmt(risk.total_cost_basis))
+        table.add_row("Market Value", _fmt(risk.total_market_value))
+        table.add_row("Unrealized PnL", _fmt(risk.unrealized_pnl))
+        table.add_row("Realized PnL", _fmt(risk.realized_pnl))
+        table.add_row("Total PnL", _fmt(risk.total_pnl))
+        table.add_row("Health Score", f"{risk.health.score}/100 ({risk.health.label})")
+        return table
+
+    def _portfolio_risk_report(self) -> PortfolioRiskReport:
+        positions = self.portfolio.list()
+        values: dict[str, tuple[float | None, float | None, float | None]] = {}
+        for row in positions:
+            values[str(row["symbol"]).upper()] = self._portfolio_market_values(row)
+        return build_portfolio_risk(positions, values, self.transactions.realized_pnl_total(), profile=self.user_profiles.get())
 
     def _get_quote(self, symbol: str) -> Quote:
         normalized = symbol.upper()
@@ -1286,26 +1475,26 @@ class CommandRouter:
         self.cache.set(cache_key, quote)
         return quote
 
-    def _provider_health_text(self) -> str:
-        try:
-            status = self._run_async(self.market_service.status())
-            base = (
-                f"Provider health: {status.status}\n"
-                f"Provider realtime: {status.realtime}\n"
-                f"Provider message: {status.message}"
-            )
-        except (FinCLIError, AttributeError) as exc:
-            base = f"Provider health: unavailable ({exc})"
-
-        results = getattr(self.market_service, "provider_results", [])[-6:]
-        if not results:
-            return f"{base}\nRecent provider results: none"
-        lines = ["Recent provider results:"]
-        for result in results:
-            missing = f"; missing={', '.join(result.missing_fields)}" if result.missing_fields else ""
-            message = f"; {result.message}" if result.message and result.message != "ok" else ""
-            lines.append(f"- {result.provider}.{result.operation}: {result.status}{missing}{message}")
-        return f"{base}\n" + "\n".join(lines)
+    def _provider_health_text(self) -> str:
+        try:
+            status = self._run_async(self.market_service.status())
+            base = (
+                f"Provider health: {status.status}\n"
+                f"Provider realtime: {status.realtime}\n"
+                f"Provider message: {status.message}"
+            )
+        except (FinCLIError, AttributeError) as exc:
+            base = f"Provider health: unavailable ({exc})"
+
+        results = getattr(self.market_service, "provider_results", [])[-6:]
+        if not results:
+            return f"{base}\nRecent provider results: none"
+        lines = ["Recent provider results:"]
+        for result in results:
+            missing = f"; missing={', '.join(result.missing_fields)}" if result.missing_fields else ""
+            message = f"; {result.message}" if result.message and result.message != "ok" else ""
+            lines.append(f"- {result.provider}.{result.operation}: {result.status}{missing}{message}")
+        return f"{base}\n" + "\n".join(lines)
 
     def _safe_quote(self, symbol: str) -> Quote | None:
         try:
@@ -1313,7 +1502,7 @@ class CommandRouter:
         except FinCLIError:
             return None
 
-    def _analysis_context(self, symbol: str) -> str:
+    def _analysis_context(self, symbol: str) -> str:
         sections: list[str] = []
         try:
             news_items = self._run_async(self.market_service.news(symbol, limit=3))
@@ -1325,36 +1514,47 @@ class CommandRouter:
             sections.append(_format_fundamental_context(fundamentals))
         except (FinCLIError, AttributeError) as exc:
             sections.append(f"Fundamentals unavailable: {exc}")
-        return "\n\n".join(sections)
-
-    def _ai_grounding_context(self, symbol: str, timeframe: str) -> str:
-        try:
-            overview = self._run_async(build_market_overview(symbol, self.market_service, timeframe))
-            quality = overview.data_quality
-            missing = ", ".join(quality.missing_fields) if quality.missing_fields else "none"
-            quality_text = (
-                f"Data Quality: {quality.score}/100 | tier={quality.tier} | freshness={quality.freshness}\n"
-                f"Provider Reliability: {quality.reliability_status} | provider={quality.provider}\n"
-                f"Missing Data: {missing}"
-            )
-        except FinCLIError as exc:
-            quality_text = (
-                "Data Quality: unavailable\n"
-                "Provider Reliability: unavailable\n"
-                f"Missing Data: market overview unavailable ({exc})"
-            )
-
-        metric_lines = []
-        for provider in self.market_service.providers:
-            metric = self.market_service.provider_metrics_snapshot().get(provider.name)
-            if metric is None:
-                metric_lines.append(f"- {provider.name}: calls=0; success_rate=0.00%; errors=0; fallbacks=0")
-            else:
-                metric_lines.append(
-                    f"- {provider.name}: calls={metric.calls}; success_rate={metric.success_rate:.2f}%; "
-                    f"errors={metric.errors}; fallbacks={metric.fallbacks}; avg_latency={metric.avg_latency_ms:.2f}ms"
-                )
-        return f"{quality_text}\nProvider Metrics:\n" + "\n".join(metric_lines)
+        return "\n\n".join(sections)
+
+    def _ai_grounding_context(self, symbol: str, timeframe: str) -> str:
+        try:
+            overview = self._run_async(build_market_overview(symbol, self.market_service, timeframe))
+            quality = overview.data_quality
+            missing = ", ".join(quality.missing_fields) if quality.missing_fields else "none"
+            quality_text = (
+                f"Data Quality: {quality.score}/100 | tier={quality.tier} | freshness={quality.freshness}\n"
+                f"Provider Reliability: {quality.reliability_status} | provider={quality.provider}\n"
+                f"Missing Data: {missing}"
+            )
+            gate = build_data_trust_gate(quality, self.market_service.provider_metrics_snapshot())
+            gate_text = gate.prompt_context()
+        except FinCLIError as exc:
+            quality_text = (
+                "Data Quality: unavailable\n"
+                "Provider Reliability: unavailable\n"
+                f"Missing Data: market overview unavailable ({exc})"
+            )
+            gate_text = (
+                "Data Trust Gate:\n"
+                "- Trust Level: blocked\n"
+                "- AI Action: no_directional_signal\n"
+                "- Confidence Cap: 20%\n"
+                "- Max Signal Strength: caution only\n"
+                "- Reasons: market overview unavailable\n"
+                "- Required Verification: provider data availability"
+            )
+
+        metric_lines = []
+        for provider in self.market_service.providers:
+            metric = self.market_service.provider_metrics_snapshot().get(provider.name)
+            if metric is None:
+                metric_lines.append(f"- {provider.name}: calls=0; success_rate=0.00%; errors=0; fallbacks=0")
+            else:
+                metric_lines.append(
+                    f"- {provider.name}: calls={metric.calls}; success_rate={metric.success_rate:.2f}%; "
+                    f"errors={metric.errors}; fallbacks={metric.fallbacks}; avg_latency={metric.avg_latency_ms:.2f}ms"
+                )
+        return f"{quality_text}\n{gate_text}\nProvider Metrics:\n" + "\n".join(metric_lines)
 
     def _freechat_market_context(self, prompt: str) -> str:
         symbols = extract_market_symbols(prompt)
@@ -1471,51 +1671,59 @@ class CommandRouter:
     def _build_market_service(self, injected_provider: BaseMarketProvider | None = None) -> MarketDataService:
         if injected_provider is not None:
             return MarketDataService(
-                [injected_provider],
-                cache=self.market_cache,
-                cache_ttl_seconds=self.config.settings.cache_ttl_seconds,
-                metrics_store=self.provider_metrics_store,
-            )
+                [injected_provider],
+                cache=self.market_cache,
+                cache_ttl_seconds=self.config.settings.cache_ttl_seconds,
+                provider_timeout_seconds=self.config.settings.provider_timeout_seconds,
+                metrics_store=self.provider_metrics_store,
+                symbol_resolver=self.symbol_resolver,
+                circuit_breaker_failure_threshold=self.config.settings.provider_circuit_breaker_failure_threshold,
+                circuit_breaker_cooldown_seconds=self.config.settings.provider_circuit_breaker_cooldown_seconds,
+            )
         priority = self.config.settings.market_provider_priority or [self.config.settings.market_provider]
         return MarketDataService(
-            self.market_manager.create_many(priority),
-            cache=self.market_cache,
-            cache_ttl_seconds=self.config.settings.cache_ttl_seconds,
-            metrics_store=self.provider_metrics_store,
-        )
+            self.market_manager.create_many(priority),
+            cache=self.market_cache,
+            cache_ttl_seconds=self.config.settings.cache_ttl_seconds,
+            provider_timeout_seconds=self.config.settings.provider_timeout_seconds,
+            metrics_store=self.provider_metrics_store,
+            symbol_resolver=self.symbol_resolver,
+            circuit_breaker_failure_threshold=self.config.settings.provider_circuit_breaker_failure_threshold,
+            circuit_breaker_cooldown_seconds=self.config.settings.provider_circuit_breaker_cooldown_seconds,
+        )
 
     def _refresh_market_service(self) -> None:
         self.market_service = self._build_market_service()
         self.market_provider = self.market_service.primary_provider
 
-    def _priority_tail(self, active_provider: str) -> list[str]:
-        active = active_provider.lower()
-        existing = self.config.settings.market_provider_priority or ["yfinance"]
-        tail = [provider for provider in existing if provider != active]
-        if active != "yfinance" and "yfinance" not in tail:
-            tail.append("yfinance")
-        return tail
-
-    def _news_priority_tail(self, active_provider: str) -> list[str]:
-        active = active_provider.lower()
-        existing = self.config.settings.news_provider_priority or ["yfinance", "google_news_rss", "yahoo_finance_rss"]
-        tail = [provider for provider in existing if provider != active]
-        if active != "yfinance" and "yfinance" not in tail:
-            tail.append("yfinance")
-        if active != "google_news_rss" and "google_news_rss" not in tail:
-            tail.append("google_news_rss")
-        return tail
-
-    def _validate_news_providers(self, providers: list[str]) -> None:
-        market_names = {provider.name for provider in self.market_service.providers}
-        known = {"yfinance", *market_names}
-        known.update(connector.slug for connector in self.news_connector_catalog.all())
-        unknown = [provider for provider in providers if provider not in known]
-        if unknown:
-            raise CommandError(
-                f"News provider tidak dikenal: {', '.join(unknown)}",
-                "Gunakan /news_model list atau /news_model search <query> untuk melihat provider yang tersedia.",
-            )
+    def _priority_tail(self, active_provider: str) -> list[str]:
+        active = active_provider.lower()
+        existing = self.config.settings.market_provider_priority or ["yfinance"]
+        tail = [provider for provider in existing if provider != active]
+        if active != "yfinance" and "yfinance" not in tail:
+            tail.append("yfinance")
+        return tail
+
+    def _news_priority_tail(self, active_provider: str) -> list[str]:
+        active = active_provider.lower()
+        existing = self.config.settings.news_provider_priority or ["yfinance", "google_news_rss", "yahoo_finance_rss"]
+        tail = [provider for provider in existing if provider != active]
+        if active != "yfinance" and "yfinance" not in tail:
+            tail.append("yfinance")
+        if active != "google_news_rss" and "google_news_rss" not in tail:
+            tail.append("google_news_rss")
+        return tail
+
+    def _validate_news_providers(self, providers: list[str]) -> None:
+        market_names = {provider.name for provider in self.market_service.providers}
+        known = {"yfinance", *market_names}
+        known.update(connector.slug for connector in self.news_connector_catalog.all())
+        unknown = [provider for provider in providers if provider not in known]
+        if unknown:
+            raise CommandError(
+                f"News provider tidak dikenal: {', '.join(unknown)}",
+                "Gunakan /news_model list atau /news_model search <query> untuk melihat provider yang tersedia.",
+            )
 
 
 def _format_quote(quote: Quote) -> str:
@@ -1632,7 +1840,7 @@ def _format_dashboard(
         if portfolio_rows
         else "No local portfolio positions"
     )
-    table.add_row("Portfolio", portfolio_summary, "/tx add buy AAPL 10 185 | /portfolio performance")
+    table.add_row("Portfolio", portfolio_summary, "/tx add buy AAPL 10 185 | /portfolio performance")
 
     table.add_row(
         "Journal",
@@ -1643,57 +1851,57 @@ def _format_dashboard(
         "/journal stats | /journal review",
     )
 
-    table.add_row(
-        "Market",
-        "Use /market for compact quote + technical + structure + news + fundamentals.",
-        "/market AAPL 1d | /analyze AAPL 1d",
-    )
-    if unrealized != 0 or realized_pnl != 0:
-        table.add_row(
-            "Risk Color",
-            semantic_text(f"Total PnL {_fmt(realized_pnl + unrealized)} {'gain' if realized_pnl + unrealized >= 0 else 'loss'}"),
-            "green=positive | red=negative | yellow=caution",
-        )
-    return table
-
-
-def _format_market_overview(overview: MarketOverview) -> Table:
-    table = Table(title=f"Market Overview: {overview.symbol} | {overview.timeframe}", expand=True)
+    table.add_row(
+        "Market",
+        "Use /market for compact quote + technical + structure + news + fundamentals.",
+        "/market AAPL 1d | /analyze AAPL 1d",
+    )
+    if unrealized != 0 or realized_pnl != 0:
+        table.add_row(
+            "Risk Color",
+            semantic_text(f"Total PnL {_fmt(realized_pnl + unrealized)} {'gain' if realized_pnl + unrealized >= 0 else 'loss'}"),
+            "green=positive | red=negative | yellow=caution",
+        )
+    return table
+
+
+def _format_market_overview(overview: MarketOverview) -> Table:
+    table = Table(title=f"Market Overview: {overview.symbol} | {overview.timeframe}", expand=True)
     table.add_column("Section", style="cyan", no_wrap=True)
     table.add_column("Value", style="white")
     table.add_column("Context", style="dim")
 
     quality = overview.data_quality
-    table.add_row(
-        "Data Quality",
-        semantic_text(f"{quality.score}/100 | {quality.label}"),
-        (
-            f"quote={quality.quote}; ohlcv={quality.ohlcv}; news={quality.news}; "
-            f"fundamentals={quality.fundamentals}; provider={quality.provider}; "
-            f"Reliability={quality.reliability_status}; "
-            f"Missing={', '.join(quality.missing_fields) if quality.missing_fields else 'none'}"
-        ),
-    )
-    table.add_row(
-        "Quote",
-        f"{_fmt(overview.quote.price)} {overview.quote.currency}",
-        semantic_text(f"{overview.quote.provider} | {overview.quote.status} | {overview.quote.timestamp.isoformat(timespec='seconds')}"),
-    )
-    table.add_row(
-        "Technical",
-        semantic_text(f"RSI {_fmt(overview.technical.rsi)} | Trend {overview.technical.trend_bias}"),
-        f"MACD {_fmt(overview.technical.macd)} / Signal {_fmt(overview.technical.macd_signal)} | ATR {_fmt(overview.technical.atr)}",
-    )
+    table.add_row(
+        "Data Quality",
+        semantic_text(quality.compact()),
+        (
+            f"quote={quality.quote}; ohlcv={quality.ohlcv}; news={quality.news}; "
+            f"fundamentals={quality.fundamentals}; provider={quality.provider}; "
+            f"Reliability={quality.reliability_status}; "
+            f"Missing={', '.join(quality.missing_fields) if quality.missing_fields else 'none'}"
+        ),
+    )
+    table.add_row(
+        "Quote",
+        f"{_fmt(overview.quote.price)} {overview.quote.currency}",
+        semantic_text(f"{overview.quote.provider} | {overview.quote.status} | {overview.quote.timestamp.isoformat(timespec='seconds')}"),
+    )
+    table.add_row(
+        "Technical",
+        semantic_text(f"RSI {_fmt(overview.technical.rsi)} | Trend {overview.technical.trend_bias}"),
+        f"MACD {_fmt(overview.technical.macd)} / Signal {_fmt(overview.technical.macd_signal)} | ATR {_fmt(overview.technical.atr)}",
+    )
     table.add_row(
         "Key Levels",
         f"Support {_fmt(overview.technical.support)} | Resistance {_fmt(overview.technical.resistance)}",
         f"Bollinger {_fmt(overview.technical.bollinger_lower)} - {_fmt(overview.technical.bollinger_upper)}",
     )
-    table.add_row(
-        "Market Structure",
-        semantic_text(f"{overview.structure.trend} | {overview.structure.latest_pattern}"),
-        f"BOS={overview.structure.break_of_structure}; CHoCH={overview.structure.change_of_character}; Liquidity={overview.structure.liquidity_area}",
-    )
+    table.add_row(
+        "Market Structure",
+        semantic_text(f"{overview.structure.trend} | {overview.structure.latest_pattern}"),
+        f"BOS={overview.structure.break_of_structure}; CHoCH={overview.structure.change_of_character}; Liquidity={overview.structure.liquidity_area}",
+    )
 
     if overview.fundamentals is not None:
         table.add_row(
@@ -1714,64 +1922,64 @@ def _format_market_overview(overview: MarketOverview) -> Table:
     else:
         table.add_row("Latest News", "N/A", "Provider did not return recent news.")
 
-    table.add_row("Disclaimer", "Informational only", "Bukan nasihat keuangan.")
-    return table
-
-
-def _format_portfolio_risk(report: PortfolioRiskReport) -> Table:
-    table = Table(title="Portfolio Risk v3 | Portfolio Risk v2 compatible", expand=True)
-    table.add_column("Section", style="cyan", no_wrap=True)
-    table.add_column("Metric", style="white", overflow="fold")
-    table.add_column("Value", justify="right", overflow="fold")
-
-    table.add_row("Health Score", report.health.label, f"{report.health.score}/100")
-    table.add_row("Health Notes", ", ".join(report.health.notes), "")
-    table.add_row("PnL Detail", "Cost Basis", _fmt(report.total_cost_basis))
-    table.add_row("PnL Detail", "Market Value", _fmt(report.total_market_value))
-    table.add_row("PnL Detail", "Realized PnL", semantic_text(_fmt(report.realized_pnl)))
-    table.add_row("PnL Detail", "Unrealized PnL", semantic_text(_fmt(report.unrealized_pnl)))
-    table.add_row("PnL Detail", "Total PnL", semantic_text(_fmt(report.total_pnl)))
-    table.add_row("Drawdown Estimate", "Unrealized drawdown vs cost basis", f"{report.drawdown_estimate:.2f}%")
-    table.add_row(
-        "Risk Budget",
-        f"{report.risk_budget.profile_gameplay} | {report.risk_budget.note}",
-        f"{_fmt(report.risk_budget.risk_per_trade)} / {_fmt(report.risk_budget.max_portfolio_risk)} {report.risk_budget.currency}",
-    )
-    table.add_row(
-        "Concentration Risk",
-        f"{report.concentration.level}: {report.concentration.top_symbol}",
-        f"{report.concentration.top_weight:.2f}%",
-    )
-    table.add_row("Concentration Risk", report.concentration.note, "")
-
-    if report.exposure_by_asset_class:
-        for exposure in report.exposure_by_asset_class.values():
-            table.add_row(
-                "Exposure by Asset Class",
-                f"{exposure.asset_class} ({exposure.count} position(s))",
-                f"{_fmt(exposure.market_value)} | {exposure.weight:.2f}%",
-            )
-    else:
-        table.add_row("Exposure by Asset Class", "No positions", "-")
-    if report.currency_exposure:
-        for exposure in report.currency_exposure.values():
-            table.add_row(
-                "Currency Exposure",
-                f"{exposure.currency} ({exposure.count} position(s))",
-                f"{_fmt(exposure.market_value)} | {exposure.weight:.2f}%",
-            )
-    else:
-        table.add_row("Currency Exposure", "No positions", "-")
-    if report.asset_class_warnings:
-        for warning in report.asset_class_warnings:
-            table.add_row("Asset-Class Cap Warning", f"{warning.level}: {warning.note}", f"cap {warning.cap:.2f}%")
-    else:
-        table.add_row("Asset-Class Cap Warning", "none", "-")
-    table.caption = "Portfolio Risk v3 is local analytics only. It is not financial advice."
-    return table
-
-
-def _format_technical(
+    table.add_row("Disclaimer", "Informational only", "Bukan nasihat keuangan.")
+    return table
+
+
+def _format_portfolio_risk(report: PortfolioRiskReport) -> Table:
+    table = Table(title="Portfolio Risk v3 | Portfolio Risk v2 compatible", expand=True)
+    table.add_column("Section", style="cyan", no_wrap=True)
+    table.add_column("Metric", style="white", overflow="fold")
+    table.add_column("Value", justify="right", overflow="fold")
+
+    table.add_row("Health Score", report.health.label, f"{report.health.score}/100")
+    table.add_row("Health Notes", ", ".join(report.health.notes), "")
+    table.add_row("PnL Detail", "Cost Basis", _fmt(report.total_cost_basis))
+    table.add_row("PnL Detail", "Market Value", _fmt(report.total_market_value))
+    table.add_row("PnL Detail", "Realized PnL", semantic_text(_fmt(report.realized_pnl)))
+    table.add_row("PnL Detail", "Unrealized PnL", semantic_text(_fmt(report.unrealized_pnl)))
+    table.add_row("PnL Detail", "Total PnL", semantic_text(_fmt(report.total_pnl)))
+    table.add_row("Drawdown Estimate", "Unrealized drawdown vs cost basis", f"{report.drawdown_estimate:.2f}%")
+    table.add_row(
+        "Risk Budget",
+        f"{report.risk_budget.profile_gameplay} | {report.risk_budget.note}",
+        f"{_fmt(report.risk_budget.risk_per_trade)} / {_fmt(report.risk_budget.max_portfolio_risk)} {report.risk_budget.currency}",
+    )
+    table.add_row(
+        "Concentration Risk",
+        f"{report.concentration.level}: {report.concentration.top_symbol}",
+        f"{report.concentration.top_weight:.2f}%",
+    )
+    table.add_row("Concentration Risk", report.concentration.note, "")
+
+    if report.exposure_by_asset_class:
+        for exposure in report.exposure_by_asset_class.values():
+            table.add_row(
+                "Exposure by Asset Class",
+                f"{exposure.asset_class} ({exposure.count} position(s))",
+                f"{_fmt(exposure.market_value)} | {exposure.weight:.2f}%",
+            )
+    else:
+        table.add_row("Exposure by Asset Class", "No positions", "-")
+    if report.currency_exposure:
+        for exposure in report.currency_exposure.values():
+            table.add_row(
+                "Currency Exposure",
+                f"{exposure.currency} ({exposure.count} position(s))",
+                f"{_fmt(exposure.market_value)} | {exposure.weight:.2f}%",
+            )
+    else:
+        table.add_row("Currency Exposure", "No positions", "-")
+    if report.asset_class_warnings:
+        for warning in report.asset_class_warnings:
+            table.add_row("Asset-Class Cap Warning", f"{warning.level}: {warning.note}", f"cap {warning.cap:.2f}%")
+    else:
+        table.add_row("Asset-Class Cap Warning", "none", "-")
+    table.caption = "Portfolio Risk v3 is local analytics only. It is not financial advice."
+    return table
+
+
+def _format_technical(
     symbol: str,
     interval: str,
     summary: TechnicalSummary,
@@ -1818,7 +2026,7 @@ def _format_structure(symbol: str, interval: str, structure: MarketStructureSumm
     )
 
 
-def _format_multi_timeframe(analysis: MultiTimeframeAnalysis) -> Table:
+def _format_multi_timeframe(analysis: MultiTimeframeAnalysis) -> Table:
     table = Table(title=f"Multi-Timeframe Analysis: {analysis.symbol}", expand=True)
     table.add_column("Timeframe", style="cyan", no_wrap=True)
     table.add_column("Status", no_wrap=True)
@@ -1833,13 +2041,13 @@ def _format_multi_timeframe(analysis: MultiTimeframeAnalysis) -> Table:
     for frame in analysis.frames:
         table.add_row(
             frame.timeframe,
-            frame.status,
-            str(frame.candles),
-            _fmt(frame.latest_close),
-            semantic_text(frame.trend_bias),
-            semantic_text(frame.structure_trend),
-            _fmt(frame.rsi),
-            _fmt(frame.macd),
+            frame.status,
+            str(frame.candles),
+            _fmt(frame.latest_close),
+            semantic_text(frame.trend_bias),
+            semantic_text(frame.structure_trend),
+            _fmt(frame.rsi),
+            _fmt(frame.macd),
             f"{_fmt(frame.support)} / {_fmt(frame.resistance)}",
             frame.note or "-",
         )
@@ -1850,15 +2058,15 @@ def _format_multi_timeframe(analysis: MultiTimeframeAnalysis) -> Table:
     return table
 
 
-def _format_backtest(result: BacktestResult) -> Table:
+def _format_backtest(result: BacktestResult) -> Table:
     table = Table(title=f"Backtest: {result.symbol} | {result.strategy} | {result.interval}", expand=True)
     table.add_column("Metric", style="cyan", no_wrap=True)
     table.add_column("Value", style="white")
     table.add_row("Candles", str(result.candles))
     table.add_row("Trades", str(len(result.trades)))
-    table.add_row("Total Return", semantic_text(f"{result.total_return_percent:.2f}% {'gain' if result.total_return_percent >= 0 else 'loss'}"))
+    table.add_row("Total Return", semantic_text(f"{result.total_return_percent:.2f}% {'gain' if result.total_return_percent >= 0 else 'loss'}"))
     table.add_row("Win Rate", f"{result.win_rate:.2f}%")
-    table.add_row("Max Drawdown", semantic_text(f"{result.max_drawdown_percent:.2f}% drawdown"))
+    table.add_row("Max Drawdown", semantic_text(f"{result.max_drawdown_percent:.2f}% drawdown"))
     table.add_row("Exposure", f"{result.exposure_percent:.2f}%")
     if result.trades:
         latest = result.trades[-1]
@@ -1874,7 +2082,7 @@ def _format_backtest(result: BacktestResult) -> Table:
     return table
 
 
-def _format_alerts(rows: list[dict[str, object]]) -> Table:
+def _format_alerts(rows: list[dict[str, object]]) -> Table:
     table = Table(title="Price Alerts", expand=True)
     table.add_column("ID", justify="right", no_wrap=True)
     table.add_column("Symbol", style="cyan", no_wrap=True)
@@ -1887,12 +2095,12 @@ def _format_alerts(rows: list[dict[str, object]]) -> Table:
         table.add_row(
             str(row["id"]),
             str(row["symbol"]),
-            str(row["condition"]),
-            _fmt(float(row["target"])),
-            semantic_text("active hold" if int(row["active"]) else f"triggered {row['triggered_at']}"),
-            str(row["note"] or "-"),
-            str(row["created_at"]),
-        )
+            str(row["condition"]),
+            _fmt(float(row["target"])),
+            semantic_text("active hold" if int(row["active"]) else f"triggered {row['triggered_at']}"),
+            str(row["note"] or "-"),
+            str(row["created_at"]),
+        )
     if not rows:
         table.add_row("-", "-", "-", "-", "-", "No alerts. Use /alert add AAPL above 200.", "-")
     return table
@@ -1911,12 +2119,12 @@ def _format_alert_checks(results: list[AlertCheckResult]) -> Table:
         table.add_row(
             str(result.id),
             result.symbol,
-            result.condition,
-            _fmt(result.target),
-            _fmt(result.current_price),
-            semantic_text("YES breakout confirmed" if result.triggered else "no hold"),
-            result.note or "-",
-        )
+            result.condition,
+            _fmt(result.target),
+            _fmt(result.current_price),
+            semantic_text("YES breakout confirmed" if result.triggered else "no hold"),
+            result.note or "-",
+        )
     if not results:
         table.add_row("-", "-", "-", "-", "-", "-", "No active alerts.")
     return table
@@ -1933,14 +2141,14 @@ def _format_scan_results(results: list[ScanResult], filter_expression: str, inte
     table.add_column("Reason")
     for result in results:
         table.add_row(
-            result.symbol,
-            _fmt(result.latest_close),
-            _fmt(result.rsi),
-            semantic_text(result.trend_bias),
-            _fmt(result.support),
-            _fmt(result.resistance),
-            semantic_text(result.reason),
-        )
+            result.symbol,
+            _fmt(result.latest_close),
+            _fmt(result.rsi),
+            semantic_text(result.trend_bias),
+            _fmt(result.support),
+            _fmt(result.resistance),
+            semantic_text(result.reason),
+        )
     if not results:
         table.add_row("-", "-", "-", "-", "-", "-", "Tidak ada symbol yang match.")
     return table
@@ -1962,28 +2170,37 @@ def _scan_result_rows(results: list[ScanResult]) -> list[dict[str, object]]:
     ]
 
 
-def _parse_timeframes(value: str) -> tuple[str, ...]:
-    frames = tuple(frame.strip().lower() for frame in value.split(",") if frame.strip())
-    if not frames:
-        raise CommandError("Timeframe tidak valid. Contoh: /mtf AAPL 1d,1h,15m")
-    if len(frames) > 6:
-        raise CommandError("Maksimal 6 timeframe dalam satu /mtf.")
-    return frames
-
-
-def _parse_news_lookback(args: list[str]) -> int | None:
-    if not args:
-        return None
-    raw = args[0].strip().lower()
-    if len(args) > 1 or not raw.endswith("d") or not raw[:-1].isdigit():
-        raise CommandError("Format: /news <symbol> [1d-30d]")
-    days = int(raw[:-1])
-    if days < 1 or days > 30:
-        raise CommandError("Lookback /news maksimal 30d. Contoh: /news TSLA 7d")
-    return days
-
-
-def _parse_calendar_args(args: list[str]) -> tuple[date, date, str | None, str | None]:
+def _parse_timeframes(value: str) -> tuple[str, ...]:
+    frames = tuple(frame.strip().lower() for frame in value.split(",") if frame.strip())
+    if not frames:
+        raise CommandError("Timeframe tidak valid. Contoh: /mtf AAPL 1d,1h,15m")
+    if len(frames) > 6:
+        raise CommandError("Maksimal 6 timeframe dalam satu /mtf.")
+    return frames
+
+
+def _parse_news_lookback(args: list[str]) -> int | None:
+    if not args:
+        return None
+    raw = args[0].strip().lower()
+    if len(args) > 1 or not raw.endswith("d") or not raw[:-1].isdigit():
+        raise CommandError("Format: /news <symbol> [1d-30d]")
+    days = int(raw[:-1])
+    if days < 1 or days > 30:
+        raise CommandError("Lookback /news maksimal 30d. Contoh: /news TSLA 7d")
+    return days
+
+
+def _extract_option_value(args: list[str], option: str) -> str | None:
+    if option not in args:
+        return None
+    index = args.index(option)
+    if len(args) <= index + 1:
+        raise CommandError(f"Format opsi: {option} <value>")
+    return args[index + 1]
+
+
+def _parse_calendar_args(args: list[str]) -> tuple[date, date, str | None, str | None]:
     country: str | None = None
     impact: str | None = None
     positional: list[str] = []
@@ -2016,77 +2233,111 @@ def _parse_calendar_args(args: list[str]) -> tuple[date, date, str | None, str |
     return start, end, country, impact
 
 
-def _parse_date_arg(value: str) -> date:
-    try:
-        return date.fromisoformat(value)
-    except ValueError as exc:
-        raise CommandError("Tanggal calendar harus format YYYY-MM-DD.") from exc
-
-
-def _calendar_fallback_note(exc: FinCLIError, has_key: bool) -> str:
-    if has_key:
-        return (
-            "FinCLI memakai fallback kategori event. "
-            "Periksa API key, entitlement/plan Finnhub, atau rate-limit untuk data aktual."
-        )
-    return "FinCLI memakai fallback kategori event. Isi FINNHUB_API_KEY untuk data aktual."
-
-
-def _calendar_static_fallback_note(provider_error: FinCLIError, public_error: FinCLIError | None) -> str:
-    _ = provider_error, public_error
-    return (
-        "Using static macro fallback. Finnhub calendar endpoint is unavailable for the current key/plan "
-        "or provider rate limit, and public calendar fallback is temporarily unavailable. "
-        "Check /provider key status, Finnhub calendar entitlement, and try again later."
-    )
-
-
-def _format_calendar(events: list[EconomicEvent], start: date, end: date, source: str, note: str) -> Table:
-    reliability = _calendar_reliability_status(events, source, note)
-    table = Table(
-        title=f"Economic Calendar | {start.isoformat()} to {end.isoformat()} | {source} | {reliability}",
-        expand=True,
-    )
-    table.add_column("Time", style="cyan", no_wrap=True, width=16, max_width=16)
-    table.add_column("Country", no_wrap=True, width=7, max_width=7)
-    table.add_column("Impact", no_wrap=True, width=6, max_width=6)
-    table.add_column("Event", style="white", overflow="fold")
-
-    for event in events:
-        event_time = event.time.isoformat(timespec="minutes") if event.time else "TBA"
-        table.add_row(
-            event_time,
-            event.country,
-            event.impact,
-            event.event,
-        )
-
-    if not events:
-        table.add_row("-", "-", "-", "Tidak ada event yang cocok dengan filter.")
-    summary = calendar_summary(events)
-    table.add_row(
-        "Summary",
-        source,
-        "-",
-        f"total={summary['total']}; high={summary.get('high', 0)}; medium={summary.get('medium', 0)}; "
-        f"low={summary.get('low', 0)}; reliability={reliability}",
-    )
-    table.add_row("Note", source, "-", note)
-    return table
-
-
-def _calendar_reliability_status(events: list[EconomicEvent], source: str, note: str) -> str:
-    normalized_source = source.lower()
-    normalized_note = note.lower()
-    if normalized_source == "finnhub" and events:
-        return STATUS_OK
-    if normalized_source == "fallback":
-        return STATUS_SCHEDULE_ONLY
-    if "static macro fallback" in normalized_note or "fallback kategori" in normalized_note:
-        return STATUS_SCHEDULE_ONLY
-    if events:
-        return STATUS_PARTIAL_DATA
-    return STATUS_UNAVAILABLE
+def _parse_date_arg(value: str) -> date:
+    try:
+        return date.fromisoformat(value)
+    except ValueError as exc:
+        raise CommandError("Tanggal calendar harus format YYYY-MM-DD.") from exc
+
+
+def _calendar_fallback_note(exc: FinCLIError, has_key: bool) -> str:
+    if has_key:
+        return (
+            "FinCLI memakai fallback kategori event. "
+            "Periksa API key, entitlement/plan Finnhub, atau rate-limit untuk data aktual."
+        )
+    return "FinCLI memakai fallback kategori event. Isi FINNHUB_API_KEY untuk data aktual."
+
+
+def _calendar_static_fallback_note(provider_error: FinCLIError, public_error: FinCLIError | None) -> str:
+    _ = provider_error, public_error
+    return (
+        "Using static macro fallback. Finnhub calendar endpoint is unavailable for the current key/plan "
+        "or provider rate limit, and public calendar fallback is temporarily unavailable. "
+        "Check /provider key status, Finnhub calendar entitlement, and try again later."
+    )
+
+
+def _format_calendar(events: list[EconomicEvent], start: date, end: date, source: str, note: str) -> Table:
+    reliability = _calendar_reliability_status(events, source, note)
+    quality = _calendar_data_quality(events, source, reliability)
+    table = Table(
+        title=f"Economic Calendar | {start.isoformat()} to {end.isoformat()} | {source} | {reliability}",
+        expand=True,
+    )
+    table.add_column("Time", style="cyan", no_wrap=True, width=16, max_width=16)
+    table.add_column("Country", no_wrap=True, width=7, max_width=7)
+    table.add_column("Impact", no_wrap=True, width=6, max_width=6)
+    table.add_column("Event", style="white", overflow="fold")
+    table.add_column("Actual", justify="right", no_wrap=True, width=10, max_width=14)
+    table.add_column("Forecast", justify="right", no_wrap=True, width=10, max_width=14)
+    table.add_column("Prev", justify="right", no_wrap=True, width=10, max_width=14)
+
+    for event in events:
+        event_time = event.time.isoformat(timespec="minutes") if event.time else "TBA"
+        table.add_row(
+            event_time,
+            event.country,
+            event.impact,
+            event.event,
+            event.actual or "-",
+            event.estimate or "-",
+            event.previous or "-",
+        )
+
+    if not events:
+        table.add_row("-", "-", "-", "Tidak ada event yang cocok dengan filter.", "-", "-", "-")
+    summary = calendar_summary(events)
+    table.add_row(
+        "Summary",
+        source,
+        "-",
+        f"total={summary['total']}; high={summary.get('high', 0)}; medium={summary.get('medium', 0)}; "
+        f"low={summary.get('low', 0)}; reliability={reliability}",
+        "-",
+        "-",
+        "-",
+    )
+    table.add_row("Note", source, "-", note, "-", "-", "-")
+    table.caption = f"Data Quality: {quality.compact()}"
+    return table
+
+
+def _calendar_reliability_status(events: list[EconomicEvent], source: str, note: str) -> str:
+    normalized_source = source.lower()
+    normalized_note = note.lower()
+    if normalized_source == "finnhub" and events:
+        return STATUS_OK
+    if normalized_source == "fallback":
+        return STATUS_SCHEDULE_ONLY
+    if "static macro fallback" in normalized_note or "fallback kategori" in normalized_note:
+        return STATUS_SCHEDULE_ONLY
+    if events:
+        return STATUS_PARTIAL_DATA
+    return STATUS_UNAVAILABLE
+
+
+def _calendar_data_quality(events: list[EconomicEvent], source: str, reliability: str) -> DataQualityReport:
+    score = 70 if events else 20
+    if reliability == STATUS_OK:
+        score = 90
+    elif reliability == STATUS_SCHEDULE_ONLY:
+        score = 45 if events else 25
+    missing = () if reliability == STATUS_OK else ("actual", "estimate", "previous")
+    tier = "strong" if score >= 85 else "usable" if score >= 65 else "partial" if score >= 40 else "weak"
+    return DataQualityReport(
+        score=score,
+        quote="not_applicable",
+        ohlcv="not_applicable",
+        news="not_applicable",
+        fundamentals=f"{len(events)} calendar event(s)",
+        provider=source,
+        tier=tier,
+        freshness="calendar_window",
+        reliability_status=reliability,
+        missing_fields=missing,
+        label=f"{tier} | {reliability}",
+    )
 
 
 def _format_provider_list() -> Table:
@@ -2120,68 +2371,72 @@ def _format_provider_entitlements(items: list[ProviderEntitlement]) -> Table:
     return table
 
 
-def _format_provider_key_status(manager: MarketProviderManager) -> Table:
-    table = Table(title="Market Provider API Key Status", expand=True)
-    table.add_column("Provider", style="cyan")
-    table.add_column("Key")
-    table.add_column("Status")
+def _format_provider_key_status(manager: MarketProviderManager) -> Table:
+    table = Table(title="Market Provider API Key Status", expand=True)
+    table.add_column("Provider", style="cyan")
+    table.add_column("Key")
+    table.add_column("Status")
     table.add_column("Source")
     for row in manager.key_status():
-        table.add_row(row["provider"], row["key"], row["status"], row["source"])
-    return table
-
-
-def _format_secrets_status(secrets: dict[str, str]) -> Table:
-    table = Table(title="Local Secrets Status", expand=True)
-    table.add_column("Key", style="cyan", no_wrap=True)
-    table.add_column("Status", no_wrap=True)
-    table.add_column("Source")
-    for key in sorted(secrets):
-        table.add_row(key, "set", "~/.fincli/secrets.env")
-    if not secrets:
-        table.add_row("-", "empty", "No local secrets stored.")
-    table.caption = "Values are never printed. Use /secrets clear before publishing screenshots or sharing a machine."
-    return table
-
-
-def _format_provider_metrics(service: MarketDataService) -> Table:
-    table = Table(title="Provider Metrics Dashboard", expand=True)
-    table.add_column("Provider", style="cyan", no_wrap=True)
-    table.add_column("Session Calls", justify="right")
-    table.add_column("All-Time Calls", justify="right")
-    table.add_column("Success Rate", justify="right")
-    table.add_column("Avg Latency", justify="right")
-    table.add_column("Fallback Count", justify="right")
-    table.add_column("Error Count", justify="right")
-    table.add_column("Last Status", no_wrap=True)
-
-    metrics = service.provider_metrics_snapshot()
-    persisted = service.metrics_store.snapshot() if getattr(service, "metrics_store", None) is not None else {}
-    for provider in service.providers:
-        name = provider.name
-        metric = metrics.get(name)
-        persisted_metric = persisted.get(name)
-        if metric is None:
-            table.add_row(name, "0", str(persisted_metric.calls if persisted_metric else 0), "0.00%", "0.00ms", "0", "0", "not_called")
-            continue
-        table.add_row(
-            name,
-            str(metric.calls),
-            str(persisted_metric.calls if persisted_metric else metric.calls),
-            f"{metric.success_rate:.2f}%",
-            f"{metric.avg_latency_ms:.2f}ms",
-            str(metric.fallbacks),
-            str(metric.errors),
-            metric.last_status,
-        )
-    table.caption = (
-        f"Active provider: {service.primary_provider.name}. "
-        "Metrics are runtime-only for the current FinCLI session."
-    )
-    return table
-
-
-def _format_symbol_search(query: str, results: list[SymbolSearchResult]) -> Table:
+        table.add_row(row["provider"], row["key"], row["status"], row["source"])
+    return table
+
+
+def _format_secrets_status(secrets: dict[str, str]) -> Table:
+    table = Table(title="Local Secrets Status", expand=True)
+    table.add_column("Key", style="cyan", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Source")
+    for key in sorted(secrets):
+        table.add_row(key, "set", "~/.fincli/secrets.env")
+    if not secrets:
+        table.add_row("-", "empty", "No local secrets stored.")
+    table.caption = "Values are never printed. Use /secrets clear before publishing screenshots or sharing a machine."
+    return table
+
+
+def _format_provider_metrics(service: MarketDataService) -> Table:
+    table = Table(title="Provider Metrics Dashboard", expand=True)
+    table.add_column("Provider", style="cyan", no_wrap=True)
+    table.add_column("Session Calls", justify="right")
+    table.add_column("All-Time Calls", justify="right")
+    table.add_column("Success Rate", justify="right")
+    table.add_column("Avg Latency", justify="right")
+    table.add_column("Fallback Count", justify="right")
+    table.add_column("Error Count", justify="right")
+    table.add_column("Circuit", no_wrap=True)
+    table.add_column("Failure Streak", justify="right")
+    table.add_column("Last Status", no_wrap=True)
+
+    metrics = service.provider_metrics_snapshot()
+    persisted = service.metrics_store.snapshot() if getattr(service, "metrics_store", None) is not None else {}
+    for provider in service.providers:
+        name = provider.name
+        metric = metrics.get(name)
+        persisted_metric = persisted.get(name)
+        if metric is None:
+            table.add_row(name, "0", str(persisted_metric.calls if persisted_metric else 0), "0.00%", "0.00ms", "0", "0", "closed", "0", "not_called")
+            continue
+        table.add_row(
+            name,
+            str(metric.calls),
+            str(persisted_metric.calls if persisted_metric else metric.calls),
+            f"{metric.success_rate:.2f}%",
+            f"{metric.avg_latency_ms:.2f}ms",
+            str(metric.fallbacks),
+            str(metric.errors),
+            "open" if metric.circuit_open else "closed",
+            str(metric.consecutive_failures),
+            metric.last_status,
+        )
+    table.caption = (
+        f"Active provider: {service.primary_provider.name}. "
+        "Session metrics reset per run; all-time calls persist in local SQLite."
+    )
+    return table
+
+
+def _format_symbol_search(query: str, results: list[SymbolSearchResult]) -> Table:
     table = Table(title=f"Symbol Search: {query}", expand=True)
     table.add_column("Symbol", style="cyan", no_wrap=True)
     table.add_column("Name", overflow="fold")
@@ -2201,20 +2456,26 @@ def _format_symbol_search(query: str, results: list[SymbolSearchResult]) -> Tabl
             result.notes or "-",
         )
     if not results:
-        table.add_row("-", "No local symbol match.", "-", "-", "-", "-", "Try /symbol normalize <symbol>.")
-    table.caption = "Use /symbol normalize <symbol> to inspect provider-specific normalization for any symbol."
+        table.add_row("-", "No local symbol match.", "-", "-", "-", "-", "Try /symbol resolve <symbol>.")
+    table.caption = "Use /symbol resolve <symbol> to inspect provider-specific normalization for any symbol."
     return table
 
 
-def _format_symbol_matrix(symbol: str) -> Table:
-    matrix = provider_symbol_matrix(symbol)
+def _format_symbol_matrix(
+    symbol: str,
+    resolver: SymbolResolver | None = None,
+    asset_class: str | None = None,
+) -> Table:
+    matrix = (resolver or SymbolResolver()).matrix(symbol)
     table = Table(title=f"Provider Symbol Normalization: {symbol}", expand=True)
     table.add_column("Provider", style="cyan", no_wrap=True)
     table.add_column("Normalized Symbol", style="white")
     table.add_column("Asset Class", no_wrap=True)
+    table.add_column("Confidence", no_wrap=True)
     table.add_column("Original", style="dim")
     for provider, resolved in matrix.items():
-        table.add_row(provider, resolved.symbol, resolved.asset_class, resolved.original)
+        asset = asset_class or resolved.asset_class
+        table.add_row(provider, resolved.symbol, asset, resolved.confidence, resolved.original)
     table.caption = "Normalization does not guarantee provider entitlement. Check /provider entitlement and provider plan."
     return table
 
@@ -2223,154 +2484,333 @@ def _provider_symbol_text(provider_symbols: dict[str, str]) -> str:
     return " | ".join(f"{provider}:{symbol}" for provider, symbol in provider_symbols.items())
 
 
-def _market_provider_secret_keys(provider: str) -> tuple[str, ...]:
-    return {
-        "custom": ("MARKET_DATA_API_KEY", "MARKET_DATA_BASE_URL"),
-        "finnhub": ("FINNHUB_API_KEY",),
-        "twelvedata": ("TWELVE_DATA_API_KEY",),
-        "alphavantage": ("ALPHA_VANTAGE_API_KEY",),
-    }.get(provider.lower(), ())
-
-
-def _format_macro_dashboard(query: str, rows: list[MacroIndicator]) -> Table:
-    table = Table(title=f"Macro Dashboard: {query.title()}", expand=True)
-    table.add_column("Indicator", style="cyan", no_wrap=True)
-    table.add_column("Region", no_wrap=True)
-    table.add_column("Value", justify="right")
-    table.add_column("Period", no_wrap=True)
-    table.add_column("Source", no_wrap=True)
-    table.add_column("Note", overflow="fold")
-    for row in rows:
-        table.add_row(row.name, row.region, row.value, row.period, row.source, row.note)
-    if not rows:
-        table.add_row("-", "-", "-", "-", "Fallback", "No macro rows matched the query.")
-    table.caption = "Fallback rows are connector-ready placeholders. Use provider keys later for exact values."
-    return table
-
-
-def _format_user_profile(profile: UserProfile | None) -> Table:
-    table = Table(title="User Gameplay Profile", expand=True)
-    table.add_column("Field", style="cyan", no_wrap=True)
-    table.add_column("Value", overflow="fold")
-    if profile is None:
-        table.add_row("Status", "Not configured")
-        table.add_row("Setup", '/profile set "Nama" <equity> <currency> <leverage> <years>')
-        table.add_row("Use", "Profile is used by /analyze for SL/TP and risk-context wording.")
-        return table
-    table.add_row("Name", profile.name)
-    table.add_row("Equity", f"{profile.equity:g} {profile.currency}")
-    table.add_row("Leverage", profile.leverage)
-    table.add_row("Investment Years", f"{profile.years_in_investment:g}")
-    table.add_row("Gameplay", profile.gameplay)
-    table.add_row("Analyze Usage", "Used by /analyze to constrain Signal, SL, TP1, TP2, TP3, and Reason.")
-    return table
-
-
-def _format_agents(agents: list[Agent], label: str) -> Table:
-    table = Table(title=f"FinCLI Agents: {label}", expand=True)
-    table.add_column("Slug", style="cyan", no_wrap=True)
-    table.add_column("Name", no_wrap=True)
-    table.add_column("Category", no_wrap=True)
-    table.add_column("Framework", overflow="fold")
-    table.add_column("Role", overflow="fold")
-    for agent in agents:
-        table.add_row(agent.slug, agent.name, agent.category, agent.framework, agent.role)
-    if not agents:
-        table.add_row("-", "-", "-", "-", "No agents matched.")
-    return table
-
-
-def _format_agent(agent: Agent) -> Panel:
-    return Panel(
-        "\n".join(
-            [
-                f"Name      : {agent.name}",
-                f"Slug      : {agent.slug}",
-                f"Category  : {agent.category}",
-                f"Framework : {agent.framework}",
-                f"Role      : {agent.role}",
-                "",
-                "Usage     : use as a thinking lens for /research and future multi-agent analysis.",
-            ]
-        ),
-        title="FinCLI Agent",
-        border_style="cyan",
-    )
-
-
-def _format_connectors(connectors: list[Connector], label: str) -> Table:
-    table = Table(title=f"Connector Catalog: {label}", expand=True)
-    table.add_column("Name", style="cyan", no_wrap=True)
-    table.add_column("Category", no_wrap=True)
-    table.add_column("Access", no_wrap=True)
-    table.add_column("Coverage", overflow="fold")
-    for connector in connectors:
-        table.add_row(connector.name, connector.category, connector.access, connector.coverage)
-    if not connectors:
-        table.add_row("-", "-", "-", "No connectors matched.")
-    table.caption = "Catalog entries are roadmap-ready; active adapters depend on implementation and entitlement."
-    return table
-
-
-def _format_news_connectors(connectors: list[NewsConnectorSpec], label: str) -> Table:
-    table = Table(title=f"News Connector Catalog: {label}", expand=True)
-    table.add_column("Slug", style="cyan", no_wrap=True)
-    table.add_column("Name", overflow="fold")
-    table.add_column("Access", no_wrap=True)
-    table.add_column("Category", no_wrap=True)
-    table.add_column("API Key", no_wrap=True)
-    table.add_column("Status", overflow="fold")
-    for connector in connectors:
-        status = "active rss" if connector.access == "public-rss" else "api-key ready"
-        if connector.slug == "custom_news":
-            status = "custom endpoint"
-        table.add_row(
-            connector.slug,
-            connector.name,
-            connector.access,
-            connector.category,
-            connector.env_key or "-",
-            status,
-        )
-    if not connectors:
-        table.add_row("-", "No news connectors matched.", "-", "-", "-", "-")
-    table.caption = (
-        "Use /news_model use <slug> for primary, /news_model priority a,b,c for fallback order, "
-        "and /news_model key <slug> <api_key> for API-key providers."
-    )
-    return table
-
-
-def _format_plugins(plugins: list[PluginManifest], status_only: bool = False) -> Table:
-    table = Table(title="FinCLI Plugins" if not status_only else "FinCLI Plugin Status", expand=True)
-    table.add_column("Name", style="cyan", no_wrap=True)
-    table.add_column("Version", no_wrap=True)
-    table.add_column("Status", no_wrap=True)
-    table.add_column("Capabilities", overflow="fold")
-    table.add_column("Commands", overflow="fold")
-    if not status_only:
-        table.add_column("Description", overflow="fold")
-    for plugin in plugins:
-        row = [
-            plugin.name,
-            plugin.version,
-            plugin.status,
-            ", ".join(plugin.capabilities) or "-",
-            ", ".join(plugin.commands) or "-",
-        ]
-        if not status_only:
-            row.append(plugin.description or "-")
-        table.add_row(*row)
-    if not plugins:
-        empty = ["-", "-", "no plugins", "-", "-"]
-        if not status_only:
-            empty.append("Create ~/.fincli/plugins/<name>/plugin.json to register a local plugin.")
-        table.add_row(*empty)
-    table.caption = "Plugins are manifest-only in v0.3.1; FinCLI does not execute plugin code yet."
-    return table
-
-
-def _format_transactions(rows: list[dict[str, object]]) -> Table:
+def _market_provider_secret_keys(provider: str) -> tuple[str, ...]:
+    return {
+        "custom": ("MARKET_DATA_API_KEY", "MARKET_DATA_BASE_URL"),
+        "finnhub": ("FINNHUB_API_KEY",),
+        "twelvedata": ("TWELVE_DATA_API_KEY",),
+        "alphavantage": ("ALPHA_VANTAGE_API_KEY",),
+    }.get(provider.lower(), ())
+
+
+def _format_macro_dashboard(query: str, rows: list[MacroIndicator]) -> Table:
+    table = Table(title=f"Macro Dashboard: {query.title()}", expand=True)
+    table.add_column("Indicator", style="cyan", no_wrap=True)
+    table.add_column("Region", no_wrap=True)
+    table.add_column("Value", justify="right")
+    table.add_column("Period", no_wrap=True)
+    table.add_column("Source", no_wrap=True)
+    table.add_column("Note", overflow="fold")
+    for row in rows:
+        table.add_row(row.name, row.region, row.value, row.period, row.source, row.note)
+    if not rows:
+        table.add_row("-", "-", "-", "-", "Fallback", "No macro rows matched the query.")
+    table.caption = "Fallback rows are connector-ready placeholders. Use provider keys later for exact values."
+    return table
+
+
+def _format_macro_indicator(indicator: str, region: str, rows: list[MacroIndicator]) -> Table:
+    table = Table(title=f"Macro Indicator: {indicator.replace('_', ' ').title()} | {region.upper()}", expand=True)
+    table.add_column("Period", style="cyan", no_wrap=True)
+    table.add_column("Indicator", no_wrap=True)
+    table.add_column("Region", no_wrap=True)
+    table.add_column("Value", justify="right")
+    table.add_column("Source", no_wrap=True)
+    table.add_column("Note", overflow="fold")
+    for row in rows:
+        table.add_row(row.period, row.name, row.region, row.value, row.source, row.note)
+    if not rows:
+        table.add_row("-", indicator, region.upper(), "-", "Alpha Vantage", "No data returned.")
+    table.caption = "Hidden macro alias. Verify releases with official sources."
+    return table
+
+
+def _format_trading_overview(realtime: RealtimeConnectorCatalog, brokers: BrokerCatalog) -> Table:
+    table = Table(title="Trading Layer v0.4.0 | Safe Execution Workspace", expand=True)
+    table.add_column("Area", style="cyan", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Detail", overflow="fold")
+    table.add_row("Real-Time Trading", "scaffold", f"{len(realtime.all())} realtime connector profile(s). Use /trading realtime.")
+    table.add_row("Broker Integrations", "catalog", f"{len(brokers.all())} broker integration profile(s). Use /trading brokers.")
+    table.add_row("Paper Trading", "active", "Local paper orders only. Use /trading paper buy AAPL 1 market 100.")
+    table.add_row("Algo Trading", "paper-only", "Strategy execution is intentionally local/paper in v0.4.0.")
+    table.add_row("Live Orders", "disabled", "No live broker orders are sent by FinCLI v0.4.0.")
+    table.caption = "Trading features are simulation/catalog first. Configure broker adapters only after explicit live-trading safety work."
+    return table
+
+
+def _format_realtime_connectors(connectors: tuple[RealtimeConnector, ...]) -> Table:
+    table = Table(title="Real-Time Connector Catalog", expand=True)
+    table.add_column("Connector", style="cyan", no_wrap=True)
+    table.add_column("Transport", no_wrap=True)
+    table.add_column("Assets", overflow="fold")
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Note", overflow="fold")
+    for connector in connectors:
+        table.add_row(
+            connector.name,
+            connector.transport,
+            ", ".join(connector.asset_classes),
+            connector.status,
+            connector.note,
+        )
+    return table
+
+
+def _format_brokers(brokers: tuple[BrokerIntegration, ...]) -> Table:
+    table = Table(title="Broker Integration Catalog", expand=True)
+    table.add_column("Broker", style="cyan", no_wrap=True)
+    table.add_column("Region", no_wrap=True)
+    table.add_column("Assets", overflow="fold")
+    table.add_column("Mode", no_wrap=True)
+    table.add_column("Note", overflow="fold")
+    for broker in brokers:
+        table.add_row(
+            broker.name,
+            broker.region,
+            ", ".join(broker.asset_classes),
+            broker.mode,
+            broker.note,
+        )
+    table.caption = "Catalog entries are not live execution adapters yet unless explicitly marked and configured."
+    return table
+
+
+def _format_paper_order(order: dict[str, object]) -> Table:
+    table = Table(title="Paper Trading Order", expand=True)
+    table.add_column("Field", style="cyan", no_wrap=True)
+    table.add_column("Value")
+    for key in ("side", "symbol", "quantity", "order_type", "price", "notional", "status", "strategy"):
+        table.add_row(key, str(order.get(key, "-")))
+    table.caption = "Paper trading only. No broker/live order was sent."
+    return table
+
+
+def _format_paper_orders(orders: list[dict[str, object]]) -> Table:
+    table = Table(title="Paper Trading Orders", expand=True)
+    table.add_column("ID", justify="right")
+    table.add_column("Side", no_wrap=True)
+    table.add_column("Symbol", style="cyan", no_wrap=True)
+    table.add_column("Qty", justify="right")
+    table.add_column("Type", no_wrap=True)
+    table.add_column("Price", justify="right")
+    table.add_column("Notional", justify="right")
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Created", no_wrap=True)
+    for order in orders:
+        table.add_row(
+            str(order.get("id", "-")),
+            str(order.get("side", "-")),
+            str(order.get("symbol", "-")),
+            _format_optional_number(order.get("quantity")),
+            str(order.get("order_type", "-")),
+            _format_optional_number(order.get("price")),
+            _format_optional_number(order.get("notional")),
+            str(order.get("status", "-")),
+            str(order.get("created_at", "-")),
+        )
+    if not orders:
+        table.add_row("-", "-", "-", "-", "-", "-", "-", "empty", "-")
+    table.caption = "Paper trading orders are stored locally in SQLite."
+    return table
+
+
+def _macro_error_row(indicator: str, region: str, exc: FinCLIError) -> MacroIndicator:
+    label = indicator.replace("_", " ").title()
+    help_text = f" {exc.help_text}" if getattr(exc, "help_text", None) else ""
+    return MacroIndicator(
+        name=label,
+        region=region.upper(),
+        value="unavailable",
+        period=date.today().isoformat(),
+        source="Alpha Vantage",
+        note=f"{exc}{help_text}",
+    )
+
+
+def _format_insider_transactions(symbol: str, rows: list[dict[str, object]]) -> Table:
+    table = Table(title=f"Finnhub Insider Transactions: {symbol}", expand=True)
+    table.add_column("Date", style="cyan", no_wrap=True)
+    table.add_column("Name", overflow="fold")
+    table.add_column("Code", no_wrap=True)
+    table.add_column("Change", justify="right")
+    table.add_column("Shares", justify="right")
+    table.add_column("Price", justify="right")
+    for row in rows:
+        table.add_row(
+            str(row.get("date") or "-"),
+            str(row.get("name") or "-"),
+            str(row.get("transaction_code") or "-"),
+            _format_optional_number(row.get("change")),
+            _format_optional_number(row.get("shares")),
+            _format_optional_number(row.get("transaction_price")),
+        )
+    if not rows:
+        table.add_row("-", "No insider transactions returned.", "-", "-", "-", "-")
+    table.caption = "Finnhub endpoint availability depends on API key, plan, and symbol coverage."
+    return table
+
+
+def _format_ipo_calendar(rows: list[dict[str, object]], start: date, end: date) -> Table:
+    table = Table(title=f"Finnhub IPO Calendar | {start.isoformat()} to {end.isoformat()}", expand=True)
+    table.add_column("Date", style="cyan", no_wrap=True)
+    table.add_column("Symbol", no_wrap=True)
+    table.add_column("Name", overflow="fold")
+    table.add_column("Exchange", no_wrap=True)
+    table.add_column("Price", justify="right")
+    table.add_column("Shares", justify="right")
+    table.add_column("Status", no_wrap=True)
+    for row in rows:
+        table.add_row(
+            str(row.get("date") or "-"),
+            str(row.get("symbol") or "-"),
+            str(row.get("name") or "-"),
+            str(row.get("exchange") or "-"),
+            str(row.get("price") or "-"),
+            _format_optional_number(row.get("shares")),
+            str(row.get("status") or "-"),
+        )
+    if not rows:
+        table.add_row("-", "-", "No IPOs returned for the selected window.", "-", "-", "-", "-")
+    table.caption = "Finnhub endpoint availability depends on API key, plan, and date coverage."
+    return table
+
+
+def _format_optional_number(value: object) -> str:
+    if value is None:
+        return "-"
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return str(value)
+    if number.is_integer():
+        return f"{number:,.0f}"
+    return f"{number:,.2f}"
+
+
+def _format_user_profile(profile: UserProfile | None) -> Table:
+    table = Table(title="User Gameplay Profile", expand=True)
+    table.add_column("Field", style="cyan", no_wrap=True)
+    table.add_column("Value", overflow="fold")
+    if profile is None:
+        table.add_row("Status", "Not configured")
+        table.add_row("Setup", '/profile set "Nama" <equity> <currency> <leverage> <years>')
+        table.add_row("Use", "Profile is used by /analyze for SL/TP and risk-context wording.")
+        return table
+    table.add_row("Name", profile.name)
+    table.add_row("Equity", f"{profile.equity:g} {profile.currency}")
+    table.add_row("Leverage", profile.leverage)
+    table.add_row("Investment Years", f"{profile.years_in_investment:g}")
+    table.add_row("Gameplay", profile.gameplay)
+    table.add_row("Analyze Usage", "Used by /analyze to constrain Signal, SL, TP1, TP2, TP3, and Reason.")
+    return table
+
+
+def _format_agents(agents: list[Agent], label: str) -> Table:
+    table = Table(title=f"FinCLI Agents: {label}", expand=True)
+    table.add_column("Slug", style="cyan", no_wrap=True)
+    table.add_column("Name", no_wrap=True)
+    table.add_column("Category", no_wrap=True)
+    table.add_column("Framework", overflow="fold")
+    table.add_column("Role", overflow="fold")
+    for agent in agents:
+        table.add_row(agent.slug, agent.name, agent.category, agent.framework, agent.role)
+    if not agents:
+        table.add_row("-", "-", "-", "-", "No agents matched.")
+    return table
+
+
+def _format_agent(agent: Agent) -> Panel:
+    return Panel(
+        "\n".join(
+            [
+                f"Name      : {agent.name}",
+                f"Slug      : {agent.slug}",
+                f"Category  : {agent.category}",
+                f"Framework : {agent.framework}",
+                f"Role      : {agent.role}",
+                "",
+                "Usage     : use as a thinking lens for /research and future multi-agent analysis.",
+            ]
+        ),
+        title="FinCLI Agent",
+        border_style="cyan",
+    )
+
+
+def _format_connectors(connectors: list[Connector], label: str) -> Table:
+    table = Table(title=f"Connector Catalog: {label}", expand=True)
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Category", no_wrap=True)
+    table.add_column("Access", no_wrap=True)
+    table.add_column("Coverage", overflow="fold")
+    for connector in connectors:
+        table.add_row(connector.name, connector.category, connector.access, connector.coverage)
+    if not connectors:
+        table.add_row("-", "-", "-", "No connectors matched.")
+    table.caption = "Catalog entries are roadmap-ready; active adapters depend on implementation and entitlement."
+    return table
+
+
+def _format_news_connectors(connectors: list[NewsConnectorSpec], label: str) -> Table:
+    table = Table(title=f"News Connector Catalog: {label}", expand=True)
+    table.add_column("Slug", style="cyan", no_wrap=True)
+    table.add_column("Name", overflow="fold")
+    table.add_column("Access", no_wrap=True)
+    table.add_column("Category", no_wrap=True)
+    table.add_column("API Key", no_wrap=True)
+    table.add_column("Status", overflow="fold")
+    for connector in connectors:
+        status = "active rss" if connector.access == "public-rss" else "api-key ready"
+        if connector.slug == "custom_news":
+            status = "custom endpoint"
+        table.add_row(
+            connector.slug,
+            connector.name,
+            connector.access,
+            connector.category,
+            connector.env_key or "-",
+            status,
+        )
+    if not connectors:
+        table.add_row("-", "No news connectors matched.", "-", "-", "-", "-")
+    table.caption = (
+        "Use /news_model use <slug> for primary, /news_model priority a,b,c for fallback order, "
+        "and /news_model key <slug> <api_key> for API-key providers."
+    )
+    return table
+
+
+def _format_plugins(plugins: list[PluginManifest], status_only: bool = False) -> Table:
+    table = Table(title="FinCLI Plugins" if not status_only else "FinCLI Plugin Status", expand=True)
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Version", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Capabilities", overflow="fold")
+    table.add_column("Commands", overflow="fold")
+    if not status_only:
+        table.add_column("Description", overflow="fold")
+    for plugin in plugins:
+        row = [
+            plugin.name,
+            plugin.version,
+            plugin.status,
+            ", ".join(plugin.capabilities) or "-",
+            ", ".join(plugin.commands) or "-",
+        ]
+        if not status_only:
+            row.append(plugin.description or "-")
+        table.add_row(*row)
+    if not plugins:
+        empty = ["-", "-", "no plugins", "-", "-"]
+        if not status_only:
+            empty.append("Create ~/.fincli/plugins/<name>/plugin.json to register a local plugin.")
+        table.add_row(*empty)
+    table.caption = "Plugins are manifest-only in v0.4.0; FinCLI does not execute plugin code yet."
+    return table
+
+
+def _format_transactions(rows: list[dict[str, object]]) -> Table:
     table = Table(title="Transaction Ledger", expand=True)
     table.add_column("ID", justify="right")
     table.add_column("Action")
@@ -2408,7 +2848,7 @@ def _format_journal_stats(stats: JournalStats) -> Table:
     return table
 
 
-def _format_news(symbol: str, items: list[NewsItem]) -> str:
+def _format_news(symbol: str, items: list[NewsItem]) -> str:
     if not items:
         return f"News: {symbol}\nBelum ada news dari provider aktif."
     lines = [f"News: {symbol}"]
@@ -2417,67 +2857,96 @@ def _format_news(symbol: str, items: list[NewsItem]) -> str:
         url = f"\n   URL: {item.url}" if item.url else ""
         summary = f"\n   Summary: {item.summary}" if item.summary else ""
         lines.append(f"{index}. {item.title}\n   Source: {item.source} | Published: {published}{summary}{url}")
-    return "\n".join(lines)
-
-
-def _format_news_desk(desk: NewsDesk) -> Table:
-    table = Table(title=f"News Desk: {desk.symbol}", expand=True)
-    table.add_column("Time", style="dim", no_wrap=True)
-    table.add_column("Source", style="cyan", no_wrap=True)
-    table.add_column("Headline", style="white", overflow="fold")
-    table.add_column("Summary", overflow="fold")
-    table.add_column("Analysis", overflow="fold")
-    for item in desk.items:
-        published = item.published_at.isoformat(timespec="minutes") if item.published_at else "unknown"
-        table.add_row(published, item.source, item.title, item.summary or "-", _news_item_analysis(item))
-    if not desk.items:
-        table.add_row("-", "-", "No news from active providers.", desk.note, "-")
-    lookback = f" | Lookback: {desk.lookback_days}d" if desk.lookback_days else ""
-    errors = f" | Errors: {len(desk.errors)}" if desk.errors else ""
-    table.caption = (
-        f"Providers: {', '.join(desk.provider_chain)}{lookback} | "
-        f"Reliability: {desk.reliability_status}{errors} | {desk.note}"
-    )
-    return table
-
-
-def _news_item_analysis(item: NewsItem) -> str:
-    text = f"{item.title} {item.summary}".lower()
-    bullish_words = ("beat", "beats", "rise", "rises", "rally", "rallies", "higher", "growth", "upgrade", "bullish", "record")
-    bearish_words = ("miss", "falls", "falling", "lower", "sink", "sinks", "down", "cut", "downgrade", "bearish", "weak")
-    caution_words = ("risk", "uncertain", "probe", "lawsuit", "volatility", "warning", "recall", "delay")
-    bullish = sum(1 for word in bullish_words if word in text)
-    bearish = sum(1 for word in bearish_words if word in text)
-    caution = sum(1 for word in caution_words if word in text)
-    if caution and caution >= max(bullish, bearish):
-        bias = "caution"
-    elif bullish > bearish:
-        bias = "bullish"
-    elif bearish > bullish:
-        bias = "bearish"
-    else:
-        bias = "neutral"
-    if item.published_at is None:
-        freshness = "date unknown"
-    else:
-        freshness = "fresh" if _news_age_days(item) <= 3 else "older context"
-    return semantic_text(f"{bias} | {freshness} | verify source before trading")
-
-
-def _news_age_days(item: NewsItem) -> int:
-    if item.published_at is None:
-        return 999
-    published = item.published_at
-    if published.tzinfo is None:
-        from datetime import timezone
-
-        published = published.replace(tzinfo=timezone.utc)
-    from datetime import datetime, timezone
-
-    return max((datetime.now(timezone.utc) - published).days, 0)
-
-
-def _format_web_results(query: str, results: list[WebSearchResult]) -> Table:
+    return "\n".join(lines)
+
+
+def _format_news_desk(desk: NewsDesk) -> Table:
+    table = Table(title=f"News Desk: {desk.symbol}", expand=True)
+    table.add_column("Time", style="dim", no_wrap=True)
+    table.add_column("Source", style="cyan", no_wrap=True)
+    table.add_column("Headline", style="white", overflow="fold")
+    table.add_column("Summary", overflow="fold")
+    table.add_column("Analysis", overflow="fold")
+    for item in desk.items:
+        published = item.published_at.isoformat(timespec="minutes") if item.published_at else "unknown"
+        table.add_row(published, item.source, item.title, item.summary or "-", _news_item_analysis(item))
+    if not desk.items:
+        table.add_row("-", "-", "No news from active providers.", desk.note, "-")
+    lookback = f" | Lookback: {desk.lookback_days}d" if desk.lookback_days else ""
+    quality = _news_data_quality(desk)
+    errors = f" | Errors: {len(desk.errors)}" if desk.errors else ""
+    table.caption = (
+        f"Providers: {', '.join(desk.provider_chain)}{lookback} | "
+        f"Reliability: {desk.reliability_status}{errors} | Data Quality: {quality.compact()} | {desk.note}"
+    )
+    return table
+
+
+def _news_item_analysis(item: NewsItem) -> str:
+    text = f"{item.title} {item.summary}".lower()
+    bullish_words = ("beat", "beats", "rise", "rises", "rally", "rallies", "higher", "growth", "upgrade", "bullish", "record")
+    bearish_words = ("miss", "falls", "falling", "lower", "sink", "sinks", "down", "cut", "downgrade", "bearish", "weak")
+    caution_words = ("risk", "uncertain", "probe", "lawsuit", "volatility", "warning", "recall", "delay")
+    bullish = sum(1 for word in bullish_words if word in text)
+    bearish = sum(1 for word in bearish_words if word in text)
+    caution = sum(1 for word in caution_words if word in text)
+    if caution and caution >= max(bullish, bearish):
+        bias = "caution"
+    elif bullish > bearish:
+        bias = "bullish"
+    elif bearish > bullish:
+        bias = "bearish"
+    else:
+        bias = "neutral"
+    if item.published_at is None:
+        freshness = "date unknown"
+    else:
+        freshness = "fresh" if _news_age_days(item) <= 3 else "older context"
+    return semantic_text(f"{bias} | {freshness} | verify source before trading")
+
+
+def _news_age_days(item: NewsItem) -> int:
+    if item.published_at is None:
+        return 999
+    published = item.published_at
+    if published.tzinfo is None:
+        from datetime import timezone
+
+        published = published.replace(tzinfo=timezone.utc)
+    from datetime import datetime, timezone
+
+    return max((datetime.now(timezone.utc) - published).days, 0)
+
+
+def _news_data_quality(desk: NewsDesk) -> DataQualityReport:
+    item_count = len(desk.items)
+    score = 20
+    if item_count >= 8:
+        score = 85
+    elif item_count >= 3:
+        score = 70
+    elif item_count >= 1:
+        score = 55
+    if desk.errors:
+        score = max(20, score - min(30, len(desk.errors) * 10))
+    missing = () if item_count else ("news",)
+    tier = "strong" if score >= 85 else "usable" if score >= 65 else "partial" if score >= 40 else "weak"
+    return DataQualityReport(
+        score=score,
+        quote="not_applicable",
+        ohlcv="not_applicable",
+        news=f"{item_count} item(s)",
+        fundamentals="not_applicable",
+        provider=", ".join(desk.provider_chain) or "unknown",
+        tier=tier,
+        freshness=f"{desk.lookback_days or 'latest'}d",
+        reliability_status=desk.reliability_status,
+        missing_fields=missing,
+        label=f"{tier} | {desk.reliability_status}",
+    )
+
+
+def _format_web_results(query: str, results: list[WebSearchResult]) -> Table:
     table = Table(title=f"Web Research: {query}", expand=True)
     table.add_column("#", justify="right", width=3)
     table.add_column("Title", style="cyan", overflow="fold")
@@ -2568,6 +3037,65 @@ def _split_command(raw: str) -> list[str]:
     return parts
 
 
+def _doctor_live_symbol(args: list[str]) -> str:
+    lowered = [arg.lower() for arg in args]
+    if "--live" not in lowered:
+        return "AAPL"
+    index = lowered.index("--live")
+    if len(args) > index + 1 and not args[index + 1].startswith("--"):
+        return args[index + 1].upper()
+    return "AAPL"
+
+
+def _router_roots() -> set[str]:
+    """Return slash command roots directly handled by CommandRouter."""
+
+    return {
+        "/agent",
+        "/ai",
+        "/ai_model",
+        "/alert",
+        "/analyze",
+        "/backtest",
+        "/cache",
+        "/calendar",
+        "/clear",
+        "/config",
+        "/connector",
+        "/dashboard",
+        "/doctor",
+        "/exit",
+        "/export",
+        "/funda",
+        "/help",
+        "/history",
+        "/journal",
+        "/macro",
+        "/market",
+        "/mtf",
+        "/news",
+        "/news_model",
+        "/plugin",
+        "/portfolio",
+        "/privacy",
+        "/profile",
+        "/provider",
+        "/quote",
+        "/report",
+        "/research",
+        "/scan",
+        "/secrets",
+        "/setup",
+        "/structure",
+        "/symbol",
+        "/technical",
+        "/tx",
+        "/watchlist",
+        "/web",
+        "/yahoo",
+    }
+
+
 def _strip_wrapping_quotes(value: str) -> str:
     if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
         return value[1:-1]