Upload 6 files

README.md

@@ -1,15 +1,61 @@
 ---
-title: StockCheck
+title: Did This Stock Actually Change
 emoji: 📉
-colorFrom: purple
-colorTo: pink
+colorFrom: red
+colorTo: green
 sdk: gradio
 sdk_version: 6.19.0
-python_version: '3.13'
 app_file: app.py
 pinned: false
 license: mit
-short_description: Fable writes code that uses Clutch2 ideas to analyze stocks.
+short_description: Which moves were real events, which were dice. No API key.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📉 Did This Stock Actually Change?
+
+Financial charts make every wiggle look like a story; most wiggles are dice. Type a
+ticker (free Yahoo data via `yfinance`, **no API key**) and get the honest split:
+
+- **Shock events** — days or clusters that broke out of the stock's normal movement,
+  with dates and sizes ("−12.3%, sharpest day ~11× normal"). Detected by the
+  [Clutch](https://huggingface.co/spaces/Aluode/Clutch2)'s leaky-integrator gate fed
+  daily returns normalized by *past-only local* volatility — so one outsized day trips
+  it instantly, several stressed days in a row accumulate and trip it too (which a
+  naive threshold misses), and a permanently rougher stock doesn't spam flags.
+- **Volatility regime changes** — "a typical day went from ±1.1% to ±2.7% around
+  2025-09-17". Non-overlapping-window vols, strongest-split ratio test, day-level
+  refinement. At most one per window: only the strongest is claimed.
+- **Drift vs luck** — the period's total return compared against what pure chance could
+  produce at this stock's wobble (2σ·√n). Most yearly stock moves are **not**
+  distinguishable from luck, and this page says so, which chart commentary never will.
+- **Free headlines** — Yahoo's keyless news feed; if a flagged event is recent, the
+  headlines may be the *why*. (Recent items only — Yahoo's free feed can't be matched
+  to events from months back.)
+
+## Measured calibration (synthetic GBM suites, "normal" suspicion)
+
+- pure random walk, 60 seeds → **2.8 shock events/yr** (these are the year's genuinely
+  biggest moves, labeled with their size in ×-normal-day units — the reader can judge)
+- a −9% overnight gap (5× daily vol) → detected **52/60**
+- three consecutive −2.2σ days (slow bleed a threshold misses) → detected **53/60**
+- constant volatility → false "regime change" **3/60**; a 1.2%→2.8% vol change →
+  detected **34/40**, flagged on average 9 days from the true day
+- the strict setting trades detection for silence (39/60 on the gap); the eager setting
+  the reverse. The slider is the trade-off, stated.
+
+Real returns are fatter-tailed than GBM, so real tickers will show somewhat more events
+than 2.8/yr — that is the data being eventful, not the detector lying.
+
+Known limits: Yahoo rate-limits shared servers occasionally (the app says so and retries
+work); very short histories (<40 days) are refused; the luck bound uses whole-period
+volatility, so a mid-window regime change widens it.
+
+Nothing is stored. This describes the past, predicts nothing, and is not investment
+advice or a recommendation to buy or sell anything.
+
+## Files
+- `stock.py` — data fetch (cached, keyless), news parser, shock gate, vol-regime test, verdicts
+- `change.py` / `clutch.py` — the shared engine from the companion Spaces
+- `app.py` — the Gradio app
+
+Built by Antti Luode (PerceptionLab). *Do not hype. Do not lie. Just show.*

app.py

@@ -0,0 +1,134 @@
+"""
+app.py — "Did This Stock Actually Change?"
+Type a ticker. Free Yahoo data comes in, and you get a plain answer: which moves in
+the past year were real events, which were ordinary wobble, whether the ride itself
+got rougher — plus the latest free headlines. No API key, no account, nothing stored.
+"""
+
+import matplotlib
+matplotlib.use("Agg")
+from matplotlib.figure import Figure
+import numpy as np
+import gradio as gr
+
+import stock
+
+INK = "#1b1b1b"
+RED = "#d64545"
+ORANGE = "#e8a33d"
+CALM = "#2e9e5b"
+
+PERIODS = {"6 months": "6mo", "1 year": "1y", "2 years": "2y"}
+SENS = {1: 1.5, 2: 1.0, 3: 0.7}  # 1 = only the undeniable … 3 = flag early
+
+
+def make_plot(ticker, dates, close, a, currency):
+    n = len(close)
+    fig = Figure(figsize=(7.6, 4.0), dpi=96)
+    ax = fig.add_subplot(111)
+    t = np.arange(n)
+    ax.plot(t, close, color=INK, lw=1.2)
+    for e in a["shocks"]:
+        ax.axvspan(e["i0"] + 1, e["i1"] + 1, color=RED, alpha=0.18)
+        mid = (e["i0"] + e["i1"]) // 2 + 1
+        ax.text(mid, float(np.max(close)), stock.pct(e["cum_ret"]),
+                color=RED, fontsize=8.5, ha="center", va="top", fontweight="bold")
+    for v in a["vols"]:
+        ax.axvline(v["at"] + 1, color=ORANGE, lw=1.6, ls="--")
+        ax.text(v["at"] + 1, float(np.min(close)), " ride changed",
+                color=ORANGE, fontsize=8.5, va="bottom", fontweight="bold")
+    # x ticks: ~6 date labels
+    idx = np.linspace(0, n - 1, 6).astype(int)
+    ax.set_xticks(idx)
+    ax.set_xticklabels([dates[i] for i in idx], fontsize=8)
+    cur = f" ({currency})" if currency else ""
+    ax.set_ylabel(f"price{cur}")
+    ne = len(a["shocks"])
+    ax.set_title(f"{ticker.upper()} — red = real events ({ne}), everything else = ordinary wobble",
+                 fontsize=11)
+    ax.grid(alpha=0.22)
+    fig.tight_layout()
+    return fig
+
+
+def news_md(ticker, items, a, dates):
+    if not items:
+        return ("*No free headlines available right now (Yahoo occasionally rate-limits "
+                "shared servers — try again in a minute).*")
+    lines = []
+    recent_shock = any(e["i1"] + 1 >= len(dates) - 15 for e in a["shocks"])
+    if recent_shock:
+        lines.append("One of the flagged events is **recent** — these headlines may be "
+                     "the *why*:")
+    lines.append(f"#### 📰 Latest free headlines for {ticker.upper()}")
+    for it in items:
+        meta = " · ".join(x for x in (it["publisher"], it["when"]) if x)
+        title = it["title"].replace("|", "-")
+        if it["url"]:
+            lines.append(f"- [{title}]({it['url']})  <small>{meta}</small>")
+        else:
+            lines.append(f"- {title}  <small>{meta}</small>")
+    lines.append("<small>Headlines are Yahoo Finance's free feed — recent items only; "
+                 "they cannot be matched to events from months ago.</small>")
+    return "\n".join(lines)
+
+
+def run_check(ticker, period_label, sensitivity):
+    ticker = (ticker or "").strip()
+    if not ticker:
+        return "Type a ticker first (Yahoo format — e.g. `AAPL`, `NOK`, `BTC-USD`, `^GSPC`).", None, ""
+    dates, close, currency, err = stock.fetch_prices(ticker, PERIODS[period_label])
+    if err:
+        return err, None, ""
+    a = stock.analyze(dates, close, SENS[int(sensitivity)])
+    md = stock.verdict_md(ticker.upper(), dates, close, a, currency)
+    fig = make_plot(ticker, dates, close, a, currency)
+    nm = news_md(ticker, stock.fetch_news(ticker), a, dates)
+    return md, fig, nm
+
+
+HEADER = """
+# 📉 Did This Stock Actually Change?
+
+Financial charts make **every** wiggle look like a story. Most wiggles are dice.
+Type any ticker and get the honest split:
+
+> which moves were **real events** (worth asking *why*), which were **ordinary
+> wobble** (worth ignoring), whether **the ride itself got rougher** — and whether the
+> period's overall drift is even **distinguishable from luck**.
+
+Free Yahoo data, free headlines, **no API key, no account, nothing stored**.
+Works for stocks (`AAPL`, `NOK`), crypto (`BTC-USD`), indices (`^GSPC`, `^OMXH25`).
+"""
+
+FOOTER = """
+---
+<small>Engine: the same *Clutch* surprise gate that powers the
+[compute demo](https://huggingface.co/spaces/Aluode/Clutch2) and
+[Did Something Actually Change?](https://huggingface.co/spaces/Aluode/DidItChange),
+here fed daily returns (shocks) and rolling volatility (regime changes), with measured
+false-alarm and detection rates in the README. It describes the past only, predicts
+nothing, and is not investment advice. Built by Antti Luode (PerceptionLab).
+*Do not hype. Do not lie. Just show.*</small>
+"""
+
+with gr.Blocks(title="Did This Stock Actually Change?") as demo:
+    gr.Markdown(HEADER)
+    with gr.Row():
+        s_ticker = gr.Textbox(label="Ticker (Yahoo format)", value="NOK", scale=2)
+        s_period = gr.Dropdown(list(PERIODS), value="1 year", label="Window", scale=1)
+        s_sens = gr.Slider(1, 3, 2, step=1, scale=2,
+                           label="suspicion (1 = only the undeniable · 3 = flag early hints)")
+        s_run = gr.Button("📉 Check it", variant="primary", scale=1)
+    with gr.Row():
+        with gr.Column(scale=3):
+            s_plot = gr.Plot(label="the year, judged")
+            s_md = gr.Markdown()
+        with gr.Column(scale=2):
+            s_news = gr.Markdown()
+    gr.Examples([["NOK"], ["AAPL"], ["NVDA"], ["BTC-USD"], ["^GSPC"]], inputs=[s_ticker])
+    s_run.click(run_check, [s_ticker, s_period, s_sens], [s_md, s_plot, s_news])
+    gr.Markdown(FOOTER)
+
+if __name__ == "__main__":
+    demo.launch()

change.py

@@ -0,0 +1,224 @@
+"""
+change.py — 'Did something actually change?' engine for normal people.
+
+Same Clutch + MagnitudeGate as the compute demo, pointed at a human question:
+is this series just its usual wobble, or did something really shift, and when?
+
+Loop (identical structure to the drift substrate):
+  cheap  = extrapolate the cached linear model of your recent numbers
+  costly = refit that model on the last `window` points
+  error  = |prediction - today's number| / typical wobble
+A gate trip == the model of "normal" broke == a real change. Trips close together
+are merged into one EVENT with a plain-language before/after summary.
+
+Honesty rules: warm-up trips are ignored, pure noise must yield "no change",
+slow steady trends are reported as trends (they never break a linear model, and
+saying otherwise would be lying).
+"""
+
+import re
+import numpy as np
+from clutch import Clutch, MagnitudeGate
+
+
+# ------------------------------------------------------------------ input
+def parse_numbers(text=None, file_obj=None):
+    raw = ""
+    if file_obj is not None:
+        path = file_obj if isinstance(file_obj, str) else getattr(file_obj, "name", None)
+        if path:
+            with open(path, "r", errors="ignore") as f:
+                raw = f.read()
+    elif text:
+        raw = text
+    if not raw.strip():
+        return None, "No numbers yet — paste some, or pick an example above."
+    rows = []
+    for line in raw.strip().splitlines():
+        nums = re.findall(r"[-+]?\d*[\.,]?\d+(?:[eE][-+]?\d+)?", line.replace(",", "."))
+        if nums:
+            rows.append([float(x) for x in nums])
+    if not rows:
+        return None, "I couldn't find any numbers in that."
+    ncol = max(len(r) for r in rows)
+    if ncol == 1:
+        y = np.array([r[0] for r in rows if len(r) == 1], float)
+    else:
+        y = np.array([r[-1] for r in rows if len(r) == ncol], float)
+    y = y[np.isfinite(y)]
+    if len(y) < 14:
+        return None, f"Only {len(y)} values — I need at least 14 to tell change from noise."
+    return y, None
+
+
+# ------------------------------------------------------------------ core
+def _wobble(y):
+    """Typical day-to-day wobble: robust std (MAD) of first differences."""
+    d = np.diff(y)
+    mad = np.median(np.abs(d - np.median(d)))
+    return float(1.4826 * mad + 1e-9)
+
+
+class _Model:
+    def __init__(self, y, window, scale):
+        self.y, self.window, self.scale = y, window, scale
+        self.t = 0
+        self.a, self.b, self.origin = 0.0, float(y[0]), 0
+        self.last_resid = 1.0
+
+    def predict(self, t):
+        return self.a * (t - self.origin) + self.b
+
+    def cheap(self, _):
+        return self.predict(self.t)
+
+    def costly(self, _):
+        lo = max(0, self.t - self.window)
+        xs = np.arange(lo, self.t + 1)
+        ys = self.y[lo:self.t + 1]
+        if len(xs) >= 2:
+            a, b = np.polyfit(xs - lo, ys, 1)
+            self.a, self.b, self.origin = float(a), float(b), lo
+        insample = float(np.mean(np.abs(np.polyval([self.a, self.b], xs - lo) - ys))) if len(xs) else 0.0
+        return self.predict(self.t), (insample / self.scale) < 1.2
+
+    def err(self, _):
+        return self.last_resid
+
+
+def detect(y, sensitivity=1.0, sigma_mode="iid"):
+    """Run the clutch over y. Returns dict with trips, events, checks, window, scale."""
+    n = len(y)
+    window = int(np.clip(n // 10, 7, 30))
+    scale = _wobble(y)                       # day-to-day wobble (for the human text)
+    # iid: noise around a trend -> one-step noise is wobble/sqrt(2)
+    # walk: random-walk-like (stock prices) -> the daily move IS the innovation
+    sigma = scale / np.sqrt(2.0) if sigma_mode == "iid" else scale
+    # sensitivity 0.5 (paranoid) .. 2.0 (relaxed): scales the trip threshold
+    gate = MagnitudeGate(gain=2.0, leak=1.8, trip=8.0 * sensitivity)
+    clutch = Clutch(gate)
+    m = _Model(y, window, sigma)
+    trips, checks = [], 0
+    for t in range(n):
+        m.t = t
+        before = clutch.stats.expensive_calls
+        pred, _mode = clutch.step(None, m.cheap, m.costly, m.err)
+        if clutch.stats.expensive_calls > before:
+            checks += 1
+            if t > window:                       # ignore warm-up
+                trips.append(t)
+        m.last_resid = abs(pred - y[t]) / sigma
+
+    # merge trips within `window` of each other into events
+    events = []
+    for t in trips:
+        if events and t - events[-1][-1] <= window:
+            events[-1].append(t)
+        else:
+            events.append([t])
+
+    out_events = []
+    for grp in events:
+        at0 = grp[0]
+        last = min(grp[-1], at0 + 3 * window)
+        lo = max(0, at0 - 2 * window)
+        hi = min(n, last + 1 + window)
+        # refine: best single step position within the local window
+        best_c, best_sse = None, np.inf
+        for c in range(lo + 3, hi - 2):
+            l, r = y[lo:c], y[c:hi]
+            sse = ((l - l.mean()) ** 2).sum() + ((r - r.mean()) ** 2).sum()
+            if sse < best_sse:
+                best_sse, best_c = sse, c
+        cp = best_c if best_c is not None else at0
+        before_mean = float(np.mean(y[lo:cp]))
+        after_mean = float(np.mean(y[cp:hi]))
+        shift = after_mean - before_mean
+        kind = "shift" if abs(shift) >= 2.0 * sigma else "blip"
+        out_events.append(dict(at=cp, span=(grp[0], last), before=before_mean,
+                               after=after_mean, shift=shift, kind=kind))
+
+    # overall slow trend (fits the whole series; never trips the gate, honestly reported)
+    xs = np.arange(n)
+    slope = float(np.polyfit(xs, y, 1)[0])
+    trend_total = slope * n
+    trendy = abs(trend_total) > 3.0 * scale and not any(e["kind"] == "shift" for e in out_events)
+
+    return dict(events=out_events, trips=trips, checks=checks, window=window,
+                scale=scale, slope=slope, trend_total=trend_total, trendy=trendy, n=n)
+
+
+# ------------------------------------------------------------------ language
+def verdict_text(y, res, unit="", period="day"):
+    u = f" {unit}" if unit else ""
+    n, scale = res["n"], res["scale"]
+    shifts = [e for e in res["events"] if e["kind"] == "shift"]
+    blips = [e for e in res["events"] if e["kind"] == "blip"]
+    lines = []
+
+    if not shifts and not res["trendy"]:
+        lines.append(f"## 😌 Just noise — nothing actually changed")
+        lines.append(f"Across all **{n} {period}s**, your numbers stayed inside their normal "
+                     f"wobble of about **±{scale:.2g}{u}** per {period}. "
+                     f"Ups and downs smaller than that are not signal — reacting to them is "
+                     f"reacting to dice rolls.")
+        if blips:
+            days = ", ".join(f"{period} {e['at']}" for e in blips)
+            lines.append(f"There were brief odd readings around **{days}**, but the numbers "
+                         f"came straight back — one-off blips, not a real change.")
+    elif res["trendy"]:
+        direction = "upward" if res["slope"] > 0 else "downward"
+        lines.append(f"## 📈 No sudden change — but a steady {direction} drift")
+        lines.append(f"Nothing jumped, but over the whole {n} {period}s your numbers drifted "
+                     f"**{res['trend_total']:+.3g}{u}** in total (about {res['slope']:+.3g}{u} "
+                     f"per {period}). Day-to-day comparisons will feel like noise (wobble "
+                     f"±{scale:.2g}{u}); the drift only shows over weeks. That slow kind of "
+                     f"change is exactly what people miss.")
+    else:
+        lines.append(f"## 🔔 Yes — something really changed")
+        for e in shifts:
+            direction = "up" if e["shift"] > 0 else "down"
+            times = abs(e["shift"]) / scale
+            lines.append(f"- Around **{period} {e['at']}**, your typical level moved "
+                         f"**{direction} from {e['before']:.3g}{u} to {e['after']:.3g}{u}** "
+                         f"({e['shift']:+.3g}{u} — about {times:.0f}× your normal {period}-to-"
+                         f"{period} wobble). That is a real shift, not luck.")
+        if blips:
+            lines.append(f"- ({len(blips)} brief blip(s) also detected that reversed on their "
+                         f"own — those you can ignore.)")
+
+    saved = (1 - res["checks"] / n) * 100
+    lines.append("")
+    lines.append(f"**Your attention, saved:** instead of judging every single {period} "
+                 f"({n} looks), checking on the **{res['checks']} {period}s flagged above** "
+                 f"would have caught everything that mattered — **{saved:.0f}% fewer looks, "
+                 f"zero missed changes** on this data.")
+    lines.append("")
+    lines.append(f"<small>How it works: a tiny model keeps predicting your next number from "
+                 f"the recent trend; only when reality breaks the prediction harder than your "
+                 f"normal wobble (±{scale:.2g}{u}) does it flag a change. This is a statistics "
+                 f"tool, not medical or financial advice.</small>")
+    return "\n".join(lines)
+
+
+# ------------------------------------------------------------------ examples
+def example_series(name, seed=3):
+    rng = np.random.default_rng(seed)
+    if name.startswith("Weight"):
+        n = 90
+        y = 84.0 + rng.normal(0, 0.45, n)
+        y[52:] -= np.linspace(0, 0.11 * (n - 52), n - 52)   # diet bites ~day 52 (~0.8 kg/wk)
+        return np.round(y, 1), "kg", "day"
+    if name.startswith("Sleep"):
+        n = 60
+        y = 7.1 + rng.normal(0, 0.55, n)             # pure noise: nothing changed
+        return np.round(y, 1), "h", "night"
+    if name.startswith("Electricity"):
+        n = 52
+        y = 62 + rng.normal(0, 4.5, n)
+        y[30:] += 21                                  # heater breaks / tariff jumps week 30
+        return np.round(y, 1), "€", "week"
+    # "Spending — slow creep"
+    n = 80
+    y = 31 + np.linspace(0, 13.0, n) + rng.normal(0, 2.2, n)  # lifestyle creep, no jump
+    return np.round(y, 2), "€", "day"

clutch.py

@@ -0,0 +1,143 @@
+"""
+clutch.py — a substrate-agnostic dual-process controller.
+
+Distilled from Antti Luode's Loom Navigator. The one reusable idea in that demo:
+run a CHEAP cached policy by default, and only pay for an EXPENSIVE planner when a
+"surprise" signal trips a gate. When calm, latch the expensive result back into the
+cheap cache.
+
+This module makes no assumptions about *what* the substrates are. You supply:
+  - cheap_step(state)      -> next action, from the cached plan (O(1)-ish)
+  - expensive_plan(state)  -> a fresh plan (may be O(N^2) or worse)
+  - error_signal(state)    -> scalar in [0, inf): "how wrong was my last prediction?"
+
+Two gate strategies are provided, corresponding to two readings of "surprise":
+  - MagnitudeGate:  leaky integrator of error, trips over a threshold. (the Loom's gate)
+  - AcceleratorGate: triggers on the *second difference* of error — the "accelerometer"
+                     / jerk reading (Park & Cohen 2025 framing). Faster, noise-sensitive.
+
+Nothing here is hyped. It's a clutch: it decides when to spend compute.
+"""
+
+from dataclasses import dataclass, field
+
+
+class MagnitudeGate:
+    """Leaky integrator of error. Trips when accumulated surprise crosses `trip`."""
+    def __init__(self, gain=5.0, leak=0.5, trip=10.0, reset=0.0):
+        self.gain, self.leak, self.trip, self.reset = gain, leak, trip, reset
+        self.surprise = 0.0
+
+    def update(self, err):
+        self.surprise = max(0.0, self.surprise + self.gain * err - self.leak)
+        return self.surprise > self.trip
+
+    def relax(self, amount=0.5):
+        self.surprise = max(0.0, self.surprise - amount)
+
+    def clear(self):
+        self.surprise = self.reset
+
+
+class AcceleratorGate:
+    """Second-difference ('jerk') detector. Trips on a sudden change in error.
+
+    Optional refractory period suppresses re-triggering for `refractory` steps after
+    a fire — the biological low-pass that makes a derivative signal usable in noise.
+    """
+    def __init__(self, trip=1.5, refractory=0):
+        self.trip, self.refractory = trip, refractory
+        self.e1 = 0.0   # err at t-1
+        self.e2 = 0.0   # err at t-2
+        self.cool = 0
+        self.surprise = 0.0  # exposed for logging/UI parity with MagnitudeGate
+
+    def update(self, err):
+        accel = err - 2.0 * self.e1 + self.e2   # discrete 2nd derivative
+        self.e2, self.e1 = self.e1, err
+        self.surprise = abs(accel)
+        if self.cool > 0:
+            self.cool -= 1
+            return False
+        if abs(accel) > self.trip:
+            self.cool = self.refractory
+            return True
+        return False
+
+    def relax(self, amount=0.5):
+        pass  # derivative gate has no accumulator to bleed
+
+    def clear(self):
+        self.e1 = self.e2 = 0.0
+        self.cool = 0
+
+
+@dataclass
+class ClutchStats:
+    steps: int = 0
+    expensive_calls: int = 0     # how many times the planner ran
+    habitual_steps: int = 0
+    cognitive_steps: int = 0
+    trips: int = 0               # gate fired
+    history: list = field(default_factory=list)  # ('H'|'C') per step
+
+
+class Clutch:
+    """The controller. Owns the mode and the gate; delegates the substrates to you."""
+    def __init__(self, gate):
+        self.gate = gate
+        self.mode = "COGNITIVE"       # start uncached: must plan first
+        self.stats = ClutchStats()
+
+    def step(self, state, cheap_step, expensive_plan, error_signal,
+             latch_when_calm=True):
+        """Advance one tick. Returns (action, mode).
+
+        cheap_step(state)     -> action or None if the cache is exhausted/invalid
+        expensive_plan(state) -> (action, calm_bool). calm_bool=True means "I found a
+                                 clean plan, safe to latch back to habit."
+        error_signal(state)   -> scalar >= 0
+        """
+        s = self.stats
+        s.steps += 1
+        err = error_signal(state)
+        tripped = self.gate.update(err)
+        if tripped:
+            s.trips += 1
+
+        if self.mode == "HABITUAL":
+            action = cheap_step(state)
+            if tripped or action is None:
+                self.mode = "COGNITIVE"          # shed the habit
+            else:
+                self.gate.relax()
+                s.habitual_steps += 1
+                s.history.append("H")
+                return action, "HABITUAL"
+
+        # COGNITIVE
+        action, calm = expensive_plan(state)
+        s.expensive_calls += 1
+        s.cognitive_steps += 1
+        s.history.append("C")
+        if latch_when_calm and calm:
+            self.gate.clear()
+            self.mode = "HABITUAL"               # latch the fresh plan
+        return action, "COGNITIVE"
+
+
+class FilteredAcceleratorGate(AcceleratorGate):
+    """Accelerometer gate with an EMA low-pass on the error before differentiating.
+    The biological analogue: dendritic integration time-constant smoothing the jerk signal.
+    """
+    def __init__(self, trip=1.5, refractory=0, alpha=0.4):
+        super().__init__(trip=trip, refractory=refractory)
+        self.alpha = alpha
+        self.filt = 0.0
+
+    def update(self, err):
+        self.filt = self.alpha * err + (1 - self.alpha) * self.filt
+        return super().update(self.filt)
+
+    def clear(self):
+        super().clear(); self.filt = 0.0

requirements.txt

@@ -0,0 +1,5 @@
+gradio==6.19.0
+numpy
+matplotlib
+yfinance
+pandas

stock.py

@@ -0,0 +1,247 @@
+"""
+stock.py — "Did this stock actually change?" on free Yahoo data (no API key).
+
+Finance-native use of the same machinery, honestly matched to how prices behave:
+  * SHOCK events  — the Clutch's MagnitudeGate fed with |daily return| / typical move.
+                    A single outsized day trips it instantly; several stressed days in a
+                    row accumulate and trip it too (which a naive threshold misses).
+  * VOLATILITY regime changes — the iid change detector (change.detect) run on rolling
+                    daily volatility: "a normal day used to be ±1.1%, now it's ±2.6%".
+  * DRIFT — total return over the window, compared against what pure luck could
+                    produce (sigma * sqrt(n)), stated plainly.
+
+Data: yfinance (Yahoo Finance scrape — free, keyless). News: yfinance's news feed,
+also keyless. Both can rate-limit; failures are reported, never faked.
+"""
+
+import time
+import numpy as np
+from clutch import Clutch, MagnitudeGate
+from change import detect
+
+# ------------------------------------------------------------------ data (keyless)
+_CACHE = {}
+_TTL = 900  # 15 min
+
+
+def fetch_prices(ticker, period="1y"):
+    """Returns (dates, close, currency, err). Cached to be polite to Yahoo."""
+    key = (ticker.upper().strip(), period, int(time.time() // _TTL))
+    if key in _CACHE:
+        return _CACHE[key]
+    try:
+        import yfinance as yf
+        tk = yf.Ticker(ticker.strip())
+        hist = tk.history(period=period, interval="1d", auto_adjust=True)
+        if hist is None or len(hist) < 40 or "Close" not in hist:
+            out = (None, None, "", f"Couldn't get enough daily data for '{ticker}'. "
+                   "Check the symbol (Yahoo format, e.g. AAPL, NOK, BTC-USD, ^GSPC).")
+        else:
+            close = hist["Close"].to_numpy(dtype=float)
+            dates = [d.strftime("%Y-%m-%d") for d in hist.index]
+            cur = ""
+            try:
+                cur = tk.fast_info.get("currency") or ""
+            except Exception:
+                pass
+            out = (dates, close, cur, None)
+    except Exception as e:
+        out = (None, None, "", f"Data fetch failed ({type(e).__name__}). Yahoo sometimes "
+               "rate-limits shared servers — wait a minute and try again.")
+    _CACHE[key] = out
+    return out
+
+
+def fetch_news(ticker, k=6):
+    """Free Yahoo headlines via yfinance; tolerant of old and new item formats."""
+    try:
+        import yfinance as yf
+        raw = yf.Ticker(ticker.strip()).news or []
+    except Exception:
+        return []
+    return parse_news(raw, k)
+
+
+def parse_news(raw, k=6):
+    items = []
+    for it in raw[: k * 2]:
+        c = it.get("content", it) if isinstance(it, dict) else {}
+        title = c.get("title") or it.get("title")
+        if not title:
+            continue
+        url = ""
+        cu = c.get("canonicalUrl") or c.get("clickThroughUrl") or {}
+        if isinstance(cu, dict):
+            url = cu.get("url", "")
+        url = url or it.get("link", "")
+        prov = c.get("provider") or {}
+        publisher = (prov.get("displayName") if isinstance(prov, dict) else None) \
+            or it.get("publisher", "")
+        when = c.get("pubDate") or c.get("displayTime") or ""
+        if not when and it.get("providerPublishTime"):
+            when = time.strftime("%Y-%m-%d", time.gmtime(it["providerPublishTime"]))
+        when = str(when)[:10]
+        items.append(dict(title=title.strip(), url=url, publisher=publisher, when=when))
+        if len(items) >= k:
+            break
+    return items
+
+
+# ------------------------------------------------------------------ analysis
+def robust_sigma(x):
+    return float(1.4826 * np.median(np.abs(x - np.median(x))) + 1e-12)
+
+
+def local_sigma(rets, win=60, warm=20):
+    """Past-only rolling robust sigma, so a rough regime stops spamming shock flags
+    but a fresh crash (judged against the calm past) still screams."""
+    g = robust_sigma(rets)
+    out = np.full(len(rets), g)
+    for i in range(warm, len(rets)):
+        out[i] = max(robust_sigma(rets[max(0, i - win):i]), 0.4 * g)
+    return out
+
+
+def shock_events(rets, sensitivity=1.0):
+    """Clutch gate on |return| / local typical move. A single outsized day trips it
+    instantly; several stressed days in a row accumulate and trip it too.
+    Returns (events, sig_global, calm_days)."""
+    sig = robust_sigma(rets)
+    loc = local_sigma(rets)
+    gate = MagnitudeGate(gain=3.0, leak=3.2, trip=8.0 * sensitivity)
+    trips = []
+    for i, r in enumerate(rets):
+        if gate.update(abs(r) / loc[i]):
+            trips.append(i)
+            gate.clear()
+    events = []
+    for i in trips:
+        if events and i - events[-1][-1] <= 3:
+            events[-1].append(i)
+        else:
+            events.append([i])
+    out = []
+    for grp in events:
+        i0 = max(0, grp[0] - 2)
+        i1 = min(len(rets) - 1, grp[-1])
+        cum = float(np.sum(rets[i0:i1 + 1]))
+        peak_i = i0 + int(np.argmax(np.abs(rets[i0:i1 + 1])))
+        peak = float(np.abs(rets[peak_i]) / loc[peak_i])
+        biggest = float(rets[peak_i])
+        out.append(dict(i0=i0, i1=i1, cum_ret=cum, peak_z=peak, biggest=biggest))
+    calm = len(rets) - sum(e["i1"] - e["i0"] + 1 for e in out)
+    return out, sig, calm
+
+
+def vol_regimes(rets, sensitivity=1.0, win=15):
+    """Non-overlapping window vols + strongest-split ratio test (near-independent
+    samples, unlike a rolling window). Reports at most one regime change — the
+    strongest — per period. Returns [] or [dict(at, before, after, ratio)]."""
+    n = len(rets)
+    m = n // win
+    if m < 8:
+        return []
+    v = np.array([robust_sigma(rets[k * win:(k + 1) * win]) for k in range(m)])
+    best = None
+    for k in range(3, m - 2):
+        before, after = float(np.median(v[:k])), float(np.median(v[k:]))
+        ratio = after / (before + 1e-12)
+        score = max(ratio, 1.0 / ratio)
+        if best is None or score > best[0]:
+            best = (score, k, before, after, ratio)
+    score, k, before, after, ratio = best
+    thresh = 1.0 + 0.75 * sensitivity   # sens 1 -> 1.75x; strict 1.5 -> ~2.1x; eager 0.7 -> ~1.5x
+    if score < thresh:
+        return []
+    # refine the change day: best day-level split within +/-2 windows of the coarse one
+    c0 = k * win
+    best_c, best_dev = c0, 0.0
+    for c in range(max(30, c0 - 2 * win), min(n - 30, c0 + 2 * win)):
+        b = robust_sigma(rets[max(0, c - 60):c])
+        a = robust_sigma(rets[c:c + 60])
+        dev = abs(np.log(a / (b + 1e-12) + 1e-12))
+        if dev > best_dev:
+            best_dev, best_c = dev, c
+    before = robust_sigma(rets[max(0, best_c - 60):best_c])
+    after = robust_sigma(rets[best_c:best_c + 60])
+    return [dict(at=best_c, before=before, after=after, ratio=after / (before + 1e-12))]
+
+
+def analyze(dates, close, sensitivity=1.0):
+    logp = np.log(np.asarray(close, float))
+    rets = np.diff(logp)
+    shocks, sig_d, calm = shock_events(rets, sensitivity)
+    vols = vol_regimes(rets, sensitivity)
+    total = float(logp[-1] - logp[0])
+    luck2 = 2.0 * sig_d * np.sqrt(len(rets))    # 2-sigma of pure-luck drift
+    return dict(rets=rets, sig_d=sig_d, shocks=shocks, vols=vols, calm=calm,
+                total=total, luck2=luck2, n=len(rets))
+
+
+# ------------------------------------------------------------------ language
+def pct(x):
+    return f"{(np.exp(x) - 1) * 100:+.1f}%"
+
+
+def verdict_md(ticker, dates, close, a, currency=""):
+    n = a["n"]
+    d0, d1 = dates[0], dates[-1]
+    sig_pct = (np.exp(a["sig_d"]) - 1) * 100
+    lines = []
+    if not a["shocks"] and not a["vols"]:
+        lines.append(f"## 😌 {ticker}: a quiet stretch — ordinary wobble only")
+        lines.append(f"Across **{n} trading days** ({d0} → {d1}), no day or cluster of days "
+                     f"broke out of this stock's normal movement (a typical day here is about "
+                     f"**±{sig_pct:.1f}%**). Every scary-looking dip in this window was "
+                     f"within what dice would produce.")
+    else:
+        k = len(a["shocks"]) + len(a["vols"])
+        lines.append(f"## 🔔 {ticker}: {k} real event{'s' if k != 1 else ''} in this window")
+        ranked = sorted(a["shocks"],
+                        key=lambda e: max(e["peak_z"], abs(e["cum_ret"]) / (a["sig_d"] + 1e-12)),
+                        reverse=True)
+        hidden = max(0, len(ranked) - 5)
+        for e in sorted(ranked[:5], key=lambda e: e["i0"]):
+            day0, day1 = dates[e["i0"] + 1], dates[e["i1"] + 1]
+            span = f"on {day1}" if e["i0"] == e["i1"] else f"over {day0} → {day1}"
+            if abs(e["cum_ret"]) < 0.5 * abs(e["biggest"]):
+                lines.append(f"- **Violent swings {span}** that largely cancelled out "
+                             f"(net {pct(e['cum_ret'])}, sharpest single day {pct(e['biggest'])}, "
+                             f"about {e['peak_z']:.0f}× normal). Something happened there even "
+                             f"though the price ended near where it started.")
+            else:
+                direction = "down" if e["cum_ret"] < 0 else "up"
+                lines.append(f"- **Shock {span}**: moved **{direction} {pct(e['cum_ret'])}** "
+                             f"(sharpest day about {e['peak_z']:.0f}× a normal day). That is a "
+                             f"real event, not wobble — worth knowing *why* (headlines below).")
+        if hidden:
+            lines.append(f"- (+ {hidden} smaller flare-up{'s' if hidden > 1 else ''} not "
+                         f"listed — nothing above {ranked[5]['peak_z']:.0f}× normal.)")
+        for v in a["vols"]:
+            day = dates[min(v["at"] + 1, len(dates) - 1)]
+            b = (np.exp(v["before"]) - 1) * 100
+            af = (np.exp(v["after"]) - 1) * 100
+            word = "rougher" if af > b else "calmer"
+            lines.append(f"- **The ride got {word} around {day}**: a typical day went from "
+                         f"about ±{b:.1f}% to ±{af:.1f}%. Same stock, different weather.")
+    # drift vs luck — the part people get wrong most
+    tot, luck = a["total"], a["luck2"]
+    lines.append("")
+    if abs(tot) > luck:
+        lines.append(f"**The drift is real too:** {pct(tot)} over the period — more than the "
+                     f"±{(np.exp(luck)-1)*100:.0f}% that pure day-to-day luck could plausibly "
+                     f"produce over {n} days.")
+    else:
+        lines.append(f"**About the overall {pct(tot)} move:** over {n} days, pure luck at this "
+                     f"stock's wobble could produce anything within about "
+                     f"±{(np.exp(luck)-1)*100:.0f}%. So the period's drift, by itself, is "
+                     f"**not distinguishable from chance** — an honest thing almost no chart "
+                     f"commentary will tell you.")
+    lines.append("")
+    lines.append(f"**Your attention, saved:** {a['calm']} of {n} days were inside the normal "
+                 f"band — days when checking the chart could tell you nothing.")
+    lines.append("")
+    lines.append("<small>This describes what already happened in free Yahoo data; it predicts "
+                 "nothing and is not investment advice or a recommendation to buy or sell "
+                 "anything. Past shocks say nothing about future ones.</small>")
+    return "\n".join(lines)