Pre-split entries ask the user (adjust both, price only, keep) instead of a silent rewrite; data-layer canary so renamed tickers (SQ→XYZ) resolve while real outages read as retry

README.md

@@ -136,8 +136,11 @@ reasoning matters.
   committee screen is skipped and past 85% the plan narrative, with the diagnostics saying so.
 - **Plain tables never wait for a model**: a CSV/XLSX with a symbol column and an
   average-cost column is read directly; the AI extractor handles transaction exports, PDFs and
-  odd layouts on the standard tier. A pre-split entry price is auto-corrected with a visible note
-  (import row and results row) — a 10:1 split can hide behind an ordinary-looking P/L.
+  odd layouts on the standard tier. A pre-split entry price is never rewritten silently: the row
+  asks which is right — adjust price and quantity, adjust price only (quantity already
+  post-split), or keep as entered — and the analysis refuses to run until the question is
+  answered; the results row shows what was chosen. A 10:1 split can hide behind an
+  ordinary-looking P/L, and only the investor knows whether their share count is pre- or post-split.
 - **Pipeline parallelism**: the portfolio strategist and the whole candidate pipeline (pool,
   live verification, fit, screens, committee) run alongside the five-lens panel; books of 30+
   names use one sample per lens.

src/market_data.py

@@ -237,6 +237,36 @@ _FAST_KEYS = [("price", "lastPrice"), ("currency", "currency"), ("mcap", "market
               ("hi52", "yearHigh"), ("lo52", "yearLow")]
 
 
+class DataUnavailable(ValueError):
+    """No price AND the market-data layer itself is not answering (a canary quote fails):
+    an outage, not a verdict on the ticker."""
+
+
+_alive_memo = {"t": 0.0, "ok": True}
+
+
+def _data_alive() -> bool:
+    """Canary: can we quote SPY right now? Memoised for 60s so a burst of misses costs one call."""
+    now = time.time()
+    if now - _alive_memo["t"] < 60:
+        return _alive_memo["ok"]
+    ok = False
+    try:
+        if NDL_KEY:
+            from . import sharadar_prices as SP
+            ok = bool((SP.snapshot("SPY") or {}).get("price"))
+    except Exception:
+        ok = False
+    if not ok:
+        try:
+            import yfinance as yf
+            ok = bool(_f(yf.Ticker("SPY").fast_info["lastPrice"]))
+        except Exception:
+            ok = False
+    _alive_memo.update(t=now, ok=ok)
+    return ok
+
+
 def fetch_holding(ticker: str) -> dict:
     """Fundamentals + price for one ticker. Layered for resilience:
     1) yfinance fast_info (chart API — rarely rate-limited): price, mcap, SMAs, 52w range
@@ -407,6 +437,8 @@ def fetch_holding(ticker: str) -> dict:
         d["panel"] = {k: (float(v) if isinstance(v, (int, float, np.floating)) else v)
                       for k, v in panel.items() if v is not None}
     if not d.get("price"):
+        if not _data_alive():      # SQ (renamed XYZ) is a miss; GOOG with every source down is an outage
+            raise DataUnavailable(f"No live price for '{t}' and the market-data sources are not responding")
         raise ValueError(f"No live price found for '{t}' — check the ticker.")
     sanitize(d)
     _cache_put(f"hold_{t}", d)

src/orchestrator.py

@@ -336,6 +336,9 @@ def run_analysis(rows: list[dict], emit, context: dict | None = None, budget_s:
     # 1 — resolve + validate
     emit(3, "Resolving your holdings…")
     holdings, errors = build_holdings(rows)
+    asks = [e for e in errors if e.get("code") == "needs_decision"]
+    if asks:      # check with the user rather than analyse a holding on a guessed cost basis
+        raise ValueError("Before running, answer the split question: " + " | ".join(e["error"] for e in asks[:3]))
     if not holdings:
         raise ValueError("No valid holdings. " + "; ".join(e["error"] for e in errors[:3]))
 

src/portfolio.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import re
 
 from .llm import call_llm, parse_json
-from .market_data import av_symbol_search, fetch_holding, fetch_long_range, fetch_splits, fx_to_usd
+from .market_data import DataUnavailable, av_symbol_search, fetch_holding, fetch_long_range, fetch_splits, fx_to_usd
 
 _TICKER_RE = re.compile(r"[A-Z0-9\-]{1,10}(\.[A-Z]{1,4})?")
 
@@ -40,6 +40,11 @@ def _quote_exists(sym: str) -> dict | None:
     row of an import because an upstream blip surfaced as a 500)."""
     try:
         return fetch_holding(sym)
+    except DataUnavailable as e:
+        _tl.errors = getattr(_tl, "errors", []) + [f"{sym}: sources down"]
+        return None
+    except ValueError:
+        return None                       # a clean miss (dead/renamed ticker): the resolver carries on
     except Exception as e:
         _tl.errors = getattr(_tl, "errors", []) + [f"{sym}: {type(e).__name__}"]
         return None
@@ -405,7 +410,8 @@ def build_holdings(rows: list[dict]) -> tuple[list[dict], list[dict]]:
         if sym not in resolved:
             resolved[sym] = r
             order.append(sym)
-        lots.setdefault(sym, []).append({"row": i, "entry": entry, "qty": qty, "bought": bought, "side": side})
+        lots.setdefault(sym, []).append({"row": i, "entry": entry, "qty": qty, "bought": bought, "side": side,
+                                         "split": str(row.get("split") or "").lower() or None})
     for sym in order:
         r = resolved[sym]
         agg = aggregate_lots(lots[sym])
@@ -415,17 +421,29 @@ def build_holdings(rows: list[dict]) -> tuple[list[dict], list[dict]]:
         entry, qty = agg["entry"], agg["qty"]
         price = r["price"]
         entry_note = None
-        try:   # a pre-split entry the user did not correct would poison P/L, tax and DCF-vs-entry
-            for w in validate_row(sym, r["data"], price, entry, sym):
-                if w.get("code") == "presplit" and (w.get("suggest") or {}).get("field") == "entry":
-                    adj = float(w["suggest"]["value"])
-                    entry_note = f"entry {entry:g} split-adjusted to {adj:g} ({w['message'].split(' — ')[0]})"
-                    if qty:
-                        qty = qty * (entry / adj)      # the same lot holds proportionally more shares
-                    entry = adj
-                    break
+        # a pre-split entry would poison P/L, tax and DCF-vs-entry — but whether the QUANTITY is
+        # pre- or post-split only the user knows (7 shares at 171 vs 70 at 17.1), so the row
+        # must carry their answer: split = "both" | "price" | "keep"; without one the run stops
+        # and asks (never a silent rewrite)
+        choice = next((l.get("split") for l in lots[sym] if l.get("split")), None)
+        try:
+            presplit = next((w for w in validate_row(sym, r["data"], price, entry, sym)
+                             if w.get("code") == "presplit" and (w.get("suggest") or {}).get("field") == "entry"), None)
         except Exception:
-            pass
+            presplit = None
+        if presplit and choice not in ("keep", "both", "price"):
+            errors.append({"row": lots[sym][0]["row"], "query": sym, "code": "needs_decision",
+                           "error": f"{sym}: {presplit['message']} Choose 'adjust price & quantity', "
+                                    f"'adjust price only' or 'keep as entered' in the row before running."})
+            continue
+        if presplit and choice in ("both", "price"):
+            adj = float(presplit["suggest"]["value"])
+            entry_note = f"entry {entry:g} split-adjusted to {adj:g} ({presplit['message'].split(' — ')[0]})"
+            if qty and choice == "both":
+                qty = qty * (entry / adj)          # the lot holds proportionally more shares
+            entry = adj
+        elif presplit and choice == "keep":
+            entry_note = f"entry {entry:g} kept as entered ({presplit['message'].split(' — ')[0]} — you confirmed it)"
         fx = fx_to_usd(r["data"].get("currency"))   # entry & price share the local currency;
         holdings.append({                            # market value converts to USD for weights
             "symbol": sym, "name": r.get("name") or sym,

static/app.js

@@ -30,7 +30,8 @@ function addRow(query = "", entry = "", qty = "", bought = "") {
   tr.querySelector(".rm").onclick = () => { tr.remove(); if (!rowsEl.children.length) addRow(); };
   const q = tr.querySelector(".q"), e = tr.querySelector(".e");
   let timer = null;
-  const kick = () => { clearTimeout(timer); timer = setTimeout(() => resolveRow(tr), 500); };
+  const kick = () => { clearTimeout(timer); delete tr.dataset.split; delete tr.dataset.presplit;
+                       timer = setTimeout(() => resolveRow(tr), 500); };
   q.addEventListener("change", kick); e.addEventListener("change", kick);
   rowsEl.appendChild(tr);
   return tr;
@@ -72,10 +73,28 @@ function applyResolved(tr, r) {
     out.innerHTML = html;
     markLots();
     for (const w of r.warnings || []) {
-      if (w.code === "presplit" && w.suggest && w.suggest.field === "entry" && tr.dataset.autosplit !== "1") {
-        tr.dataset.autosplit = "1";                       // apply once; the user can still edit
-        tr.querySelector(".e").value = w.suggest.value;
-        out.appendChild(el("div", "warn-note", `↕ ${esc(w.message)} Entry set to ${esc(String(w.suggest.value))} — edit it if that is wrong.`));
+      if (w.code === "presplit" && w.suggest && w.suggest.field === "entry") {
+        // never rewrite the user's numbers: whether the QUANTITY is pre- or post-split only
+        // they know (7 shares at 171 vs 70 at 17.13) — ask, with the maths shown
+        if (tr.dataset.split === "keep") {
+          out.appendChild(el("div", "warn-note", `↕ ${esc(w.message)} Kept as entered (you confirmed it).`));
+          continue;
+        }
+        tr.dataset.presplit = "1";
+        const entryNow = parseFloat(tr.querySelector(".e").value), qtyNow = parseFloat(tr.querySelector(".n").value);
+        const ratio = entryNow / Number(w.suggest.value);
+        const div = el("div", "warn-note", `↕ ${esc(w.message)} Which is right? `);
+        const mk = (label, fn) => { const b = el("button", "warn-apply", label); b.onclick = (ev) => { ev.preventDefault(); fn(); }; div.appendChild(b); div.appendChild(document.createTextNode(" ")); };
+        mk(`Adjust price & quantity → ${Number(w.suggest.value).toFixed(2)}${isFinite(qtyNow) ? ` × ${Math.round(qtyNow * ratio)} shares` : ""}`, () => {
+          tr.dataset.split = "both"; tr.querySelector(".e").value = w.suggest.value;
+          if (isFinite(qtyNow)) tr.querySelector(".n").value = Math.round(qtyNow * ratio * 1000) / 1000;
+          delete tr.dataset.presplit; resolveRow(tr);
+        });
+        mk(`Adjust price only → ${Number(w.suggest.value).toFixed(2)} (quantity is already post-split)`, () => {
+          tr.dataset.split = "price"; tr.querySelector(".e").value = w.suggest.value; delete tr.dataset.presplit; resolveRow(tr);
+        });
+        mk(`Keep ${entryNow} as entered`, () => { tr.dataset.split = "keep"; delete tr.dataset.presplit; resolveRow(tr); });
+        out.appendChild(div);
         continue;
       }
       const div = el("div", "warn-note", `⚠ ${esc(w.message)} `);
@@ -303,9 +322,16 @@ $("#analyze").onclick = async () => {
     entry: parseFloat(tr.querySelector(".e").value) || null,
     qty: parseFloat(tr.querySelector(".n").value) || null,
     bought: (tr.querySelector(".b") && tr.querySelector(".b").value) || null,
+    split: tr.dataset.split || null,
   })).filter(r => r.query);
   const errEl = $("#input-error"); errEl.hidden = true;
   if (!rows.length) { errEl.hidden = false; errEl.textContent = "Add at least one holding."; return; }
+  const pending = [...rowsEl.children].filter(tr => tr.dataset.presplit === "1").map(tr => tr.querySelector(".q").value.trim());
+  if (pending.length) {
+    errEl.hidden = false;
+    errEl.textContent = `Answer the split question on ${pending.join(", ")} first — the entry price looks pre-split and only you know whether the quantity is.`;
+    return;
+  }
   if (rows.some(r => !r.entry)) { errEl.hidden = false; errEl.textContent = "Every holding needs an entry price."; return; }
   const context = {
     horizon: $("#ctx-horizon").value || null,
@@ -416,7 +442,7 @@ function renderResults(R) {
     tr.innerHTML = `
       <td class="tick"><b>${esc(r.ticker)}</b><span>${esc(r.name)}</span></td>
       <td>${pct(r.weight, false)}</td>
-      <td class="${r.pl_pct >= 0 ? "up" : "dn"}">${pct(r.pl_pct)}${r.entry_note ? ` <span class="sig" title="${esc(r.entry_note)}">split-adjusted</span>` : ""}${r.n_lots > 1
+      <td class="${r.pl_pct >= 0 ? "up" : "dn"}">${pct(r.pl_pct)}${r.entry_note ? ` <span class="sig" title="${esc(r.entry_note)}">${r.entry_note.includes("kept") ? "split: kept as entered" : "split-adjusted"}</span>` : ""}${r.n_lots > 1
         ? ` <span class="sig" title="${esc(r.lot_note || "average cost of " + r.n_lots + " lots")}">${r.n_lots} lots · avg ${Number(r.entry).toFixed(2)}</span>` : ""}</td>
       <td>${r.upside === null || r.upside === undefined
         ? (r.dcf_note ? `<span class="dim" title="DCF not meaningful">${esc(r.dcf_note)}</span>` : "–")

tests/test_golden.py

@@ -99,9 +99,25 @@ def test_data_outage_reads_as_retry_not_as_unknown_ticker(monkeypatch):
     with pytest.raises(PF.LookupUnavailable) as ei:
         PF.resolve_symbol("GOOG")
     assert "temporarily unavailable" in str(ei.value)
-    # a clean miss (sources fine, nothing matches) still reads as "not found"
+    # a clean miss (sources fine, nothing matches) still reads as "not found"…
     monkeypatch.setattr(PF, "fetch_holding", lambda sym: (_ for _ in ()).throw(ValueError("no quote")))
     monkeypatch.setattr(PF, "av_symbol_search", lambda q: [])
     monkeypatch.setattr(PF, "call_llm", lambda *a, **k: "{}")
+    with pytest.raises(ValueError) as ei:
+        PF.resolve_symbol("ZZZZQQ")
+    assert "Couldn't find" in str(ei.value) and not isinstance(ei.value, PF.LookupUnavailable)
+    # …and a renamed ticker (SQ → XYZ) still falls through to the search, not to "unavailable"
+    def fetch(sym):
+        if sym == "XYZ":
+            return {"price": 60.0, "name": "Block Inc", "currency": "USD"}
+        raise ValueError("no quote")
+    monkeypatch.setattr(PF, "fetch_holding", fetch)
+    monkeypatch.setattr(PF, "av_symbol_search", lambda q: [{"av": "XYZ", "yahoo": "XYZ", "name": "Block Inc", "region": "United States"}] if q.lower() == "block inc" else [])
+    monkeypatch.setattr(PF, "call_llm", lambda *a, **k: '{"company_name": "Block Inc", "ticker": "XYZ"}')
+    r = PF.resolve_symbol("SQ")
+    assert r["symbol"] == "XYZ" and r["price"] == 60.0
+    # a genuine outage (canary down) is the retryable error
+    from src import market_data as MD
+    monkeypatch.setattr(PF, "fetch_holding", lambda sym: (_ for _ in ()).throw(MD.DataUnavailable("sources down")))
     with pytest.raises(PF.LookupUnavailable):
-        PF.resolve_symbol("GOOG")       # fetch raised → still an error, not a verdict on the ticker
+        PF.resolve_symbol("GOOG")

tests/test_recommend.py

@@ -273,15 +273,20 @@ def test_importer_reads_plain_tables_without_llm():
     assert parse_table("just some text\nwithout a table") is None
 
 
-def test_presplit_entry_is_auto_adjusted_in_the_analysis(monkeypatch):
+def test_presplit_entry_is_a_question_never_a_silent_rewrite(monkeypatch):
     from src import portfolio as PF
     monkeypatch.setattr(PF, "resolve_symbol", lambda q: {"symbol": "NFLX", "name": "Netflix", "price": 78.0, "data": {"currency": "USD"}})
     monkeypatch.setattr(PF, "fx_to_usd", lambda c: 1.0)
     monkeypatch.setattr(PF, "validate_row", lambda *a, **k: [{"code": "presplit", "message": "NFLX had a 10-for-1 split on 2025-11-17 — x",
                                                               "suggest": {"field": "entry", "value": 17.1}}])
     hs, errs = PF.build_holdings([{"query": "NFLX", "entry": 171, "qty": 5}])
+    assert not hs and errs[0]["code"] == "needs_decision" and "keep as entered" in errs[0]["error"]
+    hs, _ = PF.build_holdings([{"query": "NFLX", "entry": 171, "qty": 5, "split": "both"}])
     assert hs[0]["entry"] == 17.1 and hs[0]["qty"] == 50 and "split-adjusted" in hs[0]["entry_note"]
-    assert abs(hs[0]["pl_pct"] - (78 / 17.1 - 1)) < 1e-6
+    hs, _ = PF.build_holdings([{"query": "NFLX", "entry": 171, "qty": 5, "split": "price"}])
+    assert hs[0]["entry"] == 17.1 and hs[0]["qty"] == 5
+    hs, _ = PF.build_holdings([{"query": "NFLX", "entry": 171, "qty": 5, "split": "keep"}])
+    assert hs[0]["entry"] == 171 and hs[0]["qty"] == 5 and "kept as entered" in hs[0]["entry_note"]
 
 
 def test_strong_ok_raises_the_bar_for_flagged_names_in_a_cautious_book():