Upload folder using huggingface_hub

README.md

@@ -46,8 +46,12 @@ entry price, quantity optional), and get:
 
 With no LLM key at all the app still runs and shows the quantitative summary.
 
-Config env vars: `LLM_MODEL` (default `claude-sonnet-5`), `RUNS_PER_DAY` (default 25),
-`MAX_HOLDINGS` (default 25), `CACHE_TTL_HOURS` (default 6).
+Models are tier-routed by task demand (all env-overridable): synthesis & valuation
+judgment on Claude Opus 5 (`LLM_MODEL_TOP`), Value/Risk lenses + import on Claude
+Sonnet 5 (`LLM_MODEL`), Growth/Technical lenses on GPT-5.6 Sol (`OPENAI_MODEL`),
+Macro on Gemini 3.7 Flash (`GEMINI_MODEL`), utilities on Claude Haiku 4.5
+(`LLM_MODEL_FAST`). Other config: `RUNS_PER_DAY` (default 25), `MAX_HOLDINGS`
+(default 25), `CACHE_TTL_HOURS` (default 6).
 
 ## Run locally
 

src/ledger.py

@@ -288,7 +288,7 @@ def check_portfolio(code: str, with_events: bool = False) -> dict | None:
                 blocks.append(t + ":\n" + "\n".join(f"  - {n['headline']}" for n in heads[:6]))
         if blocks:
             out = parse_json(call_llm(_EVENT_PROMPT, "HEADLINES:\n\n" + "\n\n".join(blocks),
-                                      max_tokens=200 + 120 * len(blocks))) or {}
+                                      max_tokens=200 + 120 * len(blocks), tier="fast")) or {}
             for t, v in out.items():
                 if isinstance(v, dict) and str(v.get("severity", "none")).lower() in ("medium", "high"):
                     fresh.append({"kind": "event", "ticker": str(t).upper(),

src/llm.py

@@ -17,9 +17,20 @@ try:
 except Exception:
     CTX = ssl.create_default_context()
 
+# Model tiers, selected per task demands (researched 2026-09; all ids probed live):
+# - top:      Claude Opus 5 ($5/$25, adaptive thinking on by default) — synthesis &
+#             valuation judgment: CIO verdict, plan narrative, strategist, DCF assumptions
+# - standard: Claude Sonnet 5 ($3/$15) — Value/Risk lenses, file import
+#             GPT-5.6 Sol (~$2/$10, OpenAI flagship) — Growth/Technical lenses
+#             Gemini 3.7 Flash ($0.75/$3.75) — Macro lens
+# - fast:     Claude Haiku 4.5 ($1/$5) — ticker resolution, event scans
 LLM_MODEL = os.environ.get("LLM_MODEL", "claude-sonnet-5")
-GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-flash-lite-latest")
-OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "gpt-5.1")
+LLM_MODEL_TOP = os.environ.get("LLM_MODEL_TOP", "claude-opus-5")
+LLM_MODEL_FAST = os.environ.get("LLM_MODEL_FAST", "claude-haiku-4-5")
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-3.7-flash")
+OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "gpt-5.6-sol")
+_THINKING_HEADROOM = 6000   # Opus 5 thinks by default; thinking tokens count against
+                            # max_tokens, so top-tier calls get headroom or JSON truncates
 
 # Prompt-injection guard + hard rails, prepended to every persona system prompt.
 RAILS = (
@@ -31,13 +42,16 @@ RAILS = (
 )
 
 
-def _call_anthropic(system: str, user: str, max_tokens: int) -> str | None:
+def _call_anthropic(system: str, user: str, max_tokens: int, tier: str = "standard") -> str | None:
     key = os.environ.get("ANTHROPIC_API_KEY")
     if not key:
         return None
+    model = {"top": LLM_MODEL_TOP, "fast": LLM_MODEL_FAST}.get(tier, LLM_MODEL)
+    if tier == "top":
+        max_tokens += _THINKING_HEADROOM
     # NOTE: Claude 5 models reject the `temperature` param — determinism is enforced by the
     # deterministic validator that gates every action, not by sampling settings.
-    body = {"model": LLM_MODEL, "max_tokens": max_tokens,
+    body = {"model": model, "max_tokens": max_tokens,
             "system": system, "messages": [{"role": "user", "content": user}]}
     req = urllib.request.Request(
         "https://api.anthropic.com/v1/messages", data=json.dumps(body).encode(),
@@ -45,7 +59,8 @@ def _call_anthropic(system: str, user: str, max_tokens: int) -> str | None:
                  "content-type": "application/json"})
     for _ in range(3):
         try:
-            with urllib.request.urlopen(req, timeout=150, context=CTX) as r:
+            with urllib.request.urlopen(req, timeout=300 if tier == "top" else 150,
+                                        context=CTX) as r:
                 out = json.load(r)
             return "".join(b.get("text", "") for b in out.get("content", []))
         except Exception as e:
@@ -53,7 +68,7 @@ def _call_anthropic(system: str, user: str, max_tokens: int) -> str | None:
     return None
 
 
-def _call_gemini(system: str, user: str, max_tokens: int) -> str | None:
+def _call_gemini(system: str, user: str, max_tokens: int, tier: str = "standard") -> str | None:
     key = os.environ.get("GEMINI_API_KEY")
     if not key:
         return None
@@ -74,7 +89,7 @@ def _call_gemini(system: str, user: str, max_tokens: int) -> str | None:
         return None
 
 
-def _call_openai(system: str, user: str, max_tokens: int) -> str | None:
+def _call_openai(system: str, user: str, max_tokens: int, tier: str = "standard") -> str | None:
     key = os.environ.get("OPENAI_API_KEY")
     if not key:
         return None
@@ -98,16 +113,17 @@ _DEFAULT_ORDER = ("anthropic", "openai", "gemini")
 
 
 def call_llm(system: str, user: str, max_tokens: int = 2000,
-             prefer: str | None = None) -> str | None:
+             prefer: str | None = None, tier: str = "standard") -> str | None:
     """Try `prefer`'s provider first (persona-level model diversity — a committee of
     different models gives genuinely independent opinions), then cascade through the
-    rest so a missing key or outage never silences a persona."""
+    rest so a missing key or outage never silences a persona. `tier` selects the model
+    class by task demand: "top" for synthesis/judgment, "fast" for mechanical utilities."""
     order: list[str] = list(_DEFAULT_ORDER)
     if prefer in _PROVIDERS:
         order.remove(prefer)
         order.insert(0, prefer)
     for name in order:
-        text = _PROVIDERS[name](system, user, max_tokens)
+        text = _PROVIDERS[name](system, user, max_tokens, tier)
         if text:
             return text
     return None

src/personas.py

@@ -225,7 +225,8 @@ def damodaran_assumptions(holdings: list[dict]) -> dict:
         chunk = lines[i:i + 6]
         user = "COMPANIES:\n" + "\n".join(chunk) + "\n\nJSON only, every ticker."
         for attempt in range(2):
-            got = parse_json(call_llm(_DAMODARAN_SYSTEM, user, max_tokens=500 + 250 * len(chunk)))
+            got = parse_json(call_llm(_DAMODARAN_SYSTEM, user, max_tokens=500 + 250 * len(chunk),
+                                      tier="top"))
             if isinstance(got, dict) and got:
                 out.update(got)
                 break
@@ -235,7 +236,8 @@ def damodaran_assumptions(holdings: list[dict]) -> dict:
 
 def _call_and_parse(system: str, payload: dict, max_tokens: int, label: str) -> dict | None:
     for attempt in range(2):
-        out = parse_json(call_llm(system, json.dumps(payload, default=str), max_tokens=max_tokens))
+        out = parse_json(call_llm(system, json.dumps(payload, default=str),
+                                  max_tokens=max_tokens, tier="top"))
         if isinstance(out, dict) and out:
             return out
         print(f"  {label} reply unparseable (attempt {attempt + 1})", flush=True)

src/portfolio.py

@@ -43,7 +43,8 @@ def resolve_symbol(query: str) -> dict:
         if d:
             return {"symbol": qU, "name": d.get("name"), "price": d["price"], "data": d}
     # not a live ticker — treat as a company name/alias
-    out = parse_json(call_llm(_RESOLVER_SYSTEM, f"Company reference: {q!r}", max_tokens=120))
+    out = parse_json(call_llm(_RESOLVER_SYSTEM, f"Company reference: {q!r}",
+                              max_tokens=120, tier="fast"))
     t = str((out or {}).get("ticker") or "").strip().upper()
     if t and _TICKER_RE.fullmatch(t):
         d = _quote_exists(t)

src/revival.py

@@ -192,7 +192,8 @@ def narrative(plan: dict) -> dict | None:
         return None
     import json
     for _ in range(2):
-        out = parse_json(call_llm(_PLAN_SYSTEM, json.dumps(plan, default=str), max_tokens=1200))
+        out = parse_json(call_llm(_PLAN_SYSTEM, json.dumps(plan, default=str),
+                                  max_tokens=1200, tier="top"))
         if isinstance(out, dict) and out.get("moves"):
             return out
     return None