README.md

@@ -1,3 +1,80 @@
-# Mainline
+# MAINLINE
 
-A full-screen terminal news stream in a Matrix/THX-1138 aesthetic — scrolling live global headlines in large block type, with per-region translation and mic-reactive glitch effects. Supports a --poetry mode for public-domain literary passages.
+> *Digital consciousness stream. Matrix aesthetic · THX-1138 hue.*
+
+A full-screen terminal news ticker that renders live global headlines in large OTF-font block characters with a white-hot → deep green gradient. Headlines auto-translate into the native script of their subject region. Ambient mic input warps the glitch rate in real time. A `--poetry` mode replaces the feed with public-domain literary passages.
+
+---
+
+## Run
+
+```bash
+python3 mainline.py            # news stream
+python3 mainline.py --poetry   # literary consciousness mode
+python3 mainline.py -p         # same
+```
+
+First run bootstraps a local `.mainline_venv/` and installs deps (`feedparser`, `Pillow`, `sounddevice`, `numpy`). Subsequent runs start immediately.
+
+---
+
+## Config
+
+At the top of `mainline.py`:
+
+| Constant | Default | What it does |
+|---|---|---|
+| `HEADLINE_LIMIT` | `1000` | Total headlines per session |
+| `MIC_THRESHOLD_DB` | `50` | dB floor above which glitches spike |
+| `_FONT_PATH` | hardcoded path | Path to your OTF/TTF display font |
+| `_FONT_SZ` | `60` | Font render size (affects block density) |
+| `_RENDER_H` | `8` | Terminal rows per headline line |
+
+**Font:** `_FONT_PATH` is hardcoded to a local path. Update it to point to whatever display font you want — anything with strong contrast and wide letterforms works well.
+
+---
+
+## How it works
+
+- Feeds are fetched and filtered on startup (sports and vapid content stripped)
+- Headlines are rasterized via Pillow into half-block characters (`▀▄█ `) at the configured font size
+- A left-to-right ANSI gradient colors each character: white-hot leading edge trails off to near-black
+- Subject-region detection runs a regex pass on each headline; matches trigger a Google Translate call and font swap to the appropriate script (CJK, Arabic, Devanagari, etc.) using macOS system fonts
+- The mic stream runs in a background thread, feeding RMS dB into the glitch probability calculation each frame
+- The viewport scrolls through a virtual canvas of pre-rendered blocks; fade zones at top and bottom dissolve characters probabilistically
+
+---
+
+## Feeds
+
+~25 sources across four categories: **Science & Technology**, **Economics & Business**, **World & Politics**, **Culture & Ideas**. Add or swap in `FEEDS`.
+
+**Poetry mode** pulls from Project Gutenberg: Whitman, Dickinson, Thoreau, Emerson.
+
+---
+
+## Ideas / Future
+
+### Performance
+- **Concurrent feed fetching** — startup currently blocks sequentially on ~25 HTTP requests; `concurrent.futures.ThreadPoolExecutor` would cut load time to the slowest single feed
+- **Background refresh** — re-fetch feeds in a daemon thread so a long session stays current without restart
+- **Translation pre-fetch** — run translate calls concurrently during the boot sequence rather than on first render
+
+### Graphics
+- **Matrix rain underlay** — katakana column rain rendered at low opacity beneath the scrolling blocks as a background layer
+- **Animated gradient** — shift the white-hot leading edge left/right each frame for a pulse/comet effect
+- **CRT simulation** — subtle dim scanlines every N rows, occasional brightness ripple across the full screen
+- **Sixel / iTerm2 inline images** — bypass half-blocks entirely and stream actual bitmap frames for true resolution; would require a capable terminal
+- **Parallax secondary column** — a second, dimmer, faster-scrolling stream of ambient text at reduced opacity on one side
+
+### Cyberpunk Vibes
+- **Keyword watch list** — highlight or strobe any headline matching tracked terms (names, topics, tickers)
+- **Breaking interrupt** — full-screen flash + synthesized blip when a high-priority keyword hits
+- **Live data overlay** — secondary ticker strip at screen edge: BTC price, ISS position, geomagnetic index
+- **Theme switcher** — `--amber` (phosphor), `--ice` (electric cyan), `--red` (alert state) palette modes via CLI flag
+- **Persona modes** — `--surveillance`, `--oracle`, `--underground` as feed presets with matching color themes and boot copy
+- **Synthesized audio** — short static bursts tied to glitch events, independent of mic input
+
+---
+
+*macOS only (system font paths hardcoded). Python 3.9+.*

mainline.py

@@ -0,0 +1,854 @@
+#!/usr/bin/env python3
+"""
+M A I N L I N E
+Digital news consciousness stream.
+Matrix aesthetic · THX-1138 hue.
+"""
+
+import subprocess, sys, os, pathlib
+
+# ─── BOOTSTRAP VENV ───────────────────────────────────────
+_VENV = pathlib.Path(__file__).resolve().parent / ".mainline_venv"
+_MARKER = _VENV / ".installed_v3"
+
+def _ensure_venv():
+    """Create a local venv and install deps if needed."""
+    if _MARKER.exists():
+        return
+    import venv
+    print("\033[2;38;5;34m  > first run — creating environment...\033[0m")
+    venv.create(str(_VENV), with_pip=True, clear=True)
+    pip = str(_VENV / "bin" / "pip")
+    subprocess.check_call(
+        [pip, "install", "feedparser", "Pillow", "-q"],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+    )
+    _MARKER.touch()
+
+_ensure_venv()
+
+# Install sounddevice on first run after v3
+_MARKER_SD = _VENV / ".installed_sd"
+if not _MARKER_SD.exists():
+    _pip = str(_VENV / "bin" / "pip")
+    subprocess.check_call([_pip, "install", "sounddevice", "numpy", "-q"],
+                          stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    _MARKER_SD.touch()
+
+sys.path.insert(0, str(next((_VENV / "lib").glob("python*/site-packages"))))
+
+import feedparser  # noqa: E402
+from PIL import Image, ImageDraw, ImageFont  # noqa: E402
+import random, time, re, signal, atexit, textwrap  # noqa: E402
+try:
+    import sounddevice as _sd
+    import numpy as _np
+    _HAS_MIC = True
+except Exception:
+    _HAS_MIC = False
+import urllib.request, urllib.parse, json  # noqa: E402
+from datetime import datetime
+from html import unescape
+from html.parser import HTMLParser
+
+# ─── CONFIG ───────────────────────────────────────────────
+HEADLINE_LIMIT = 1000
+FEED_TIMEOUT = 10
+MIC_THRESHOLD_DB = 50   # dB above which glitches intensify
+MODE = 'poetry' if '--poetry' in sys.argv or '-p' in sys.argv else 'news'
+
+# Poetry/literature sources — public domain via Project Gutenberg
+POETRY_SOURCES = {
+    "Whitman":    "https://www.gutenberg.org/cache/epub/1322/pg1322.txt",
+    "Dickinson":  "https://www.gutenberg.org/cache/epub/12242/pg12242.txt",
+    "Thoreau":    "https://www.gutenberg.org/cache/epub/205/pg205.txt",
+    "Emerson":    "https://www.gutenberg.org/cache/epub/2944/pg2944.txt",
+    "Whitman II": "https://www.gutenberg.org/cache/epub/8388/pg8388.txt",
+}
+
+# ─── ANSI ─────────────────────────────────────────────────
+RST = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+# Matrix greens
+G_HI = "\033[38;5;46m"
+G_MID = "\033[38;5;34m"
+G_LO = "\033[38;5;22m"
+G_DIM = "\033[2;38;5;34m"
+# THX-1138 sterile tones
+W_COOL = "\033[38;5;250m"
+W_DIM = "\033[2;38;5;245m"
+W_GHOST = "\033[2;38;5;238m"
+C_DIM = "\033[2;38;5;37m"
+# Terminal control
+CLR = "\033[2J\033[H"
+CURSOR_OFF = "\033[?25l"
+CURSOR_ON = "\033[?25h"
+
+# ─── FEEDS ────────────────────────────────────────────────
+FEEDS = {
+    # Science & Technology
+    "Nature": "https://www.nature.com/nature.rss",
+    "Science Daily": "https://www.sciencedaily.com/rss/all.xml",
+    "Phys.org": "https://phys.org/rss-feed/",
+    "NASA": "https://www.nasa.gov/news-release/feed/",
+    "Ars Technica": "https://feeds.arstechnica.com/arstechnica/index",
+    "New Scientist": "https://www.newscientist.com/section/news/feed/",
+    "Quanta": "https://api.quantamagazine.org/feed/",
+    "BBC Science": "http://feeds.bbci.co.uk/news/science_and_environment/rss.xml",
+    "MIT Tech Review": "https://www.technologyreview.com/feed/",
+    # Economics & Business
+    "BBC Business": "http://feeds.bbci.co.uk/news/business/rss.xml",
+    "MarketWatch": "https://feeds.marketwatch.com/marketwatch/topstories/",
+    "Economist": "https://www.economist.com/finance-and-economics/rss.xml",
+    # World & Politics
+    "BBC World": "http://feeds.bbci.co.uk/news/world/rss.xml",
+    "NPR": "https://feeds.npr.org/1001/rss.xml",
+    "Al Jazeera": "https://www.aljazeera.com/xml/rss/all.xml",
+    "Guardian World": "https://www.theguardian.com/world/rss",
+    "DW": "https://rss.dw.com/rdf/rss-en-all",
+    "France24": "https://www.france24.com/en/rss",
+    "ABC Australia": "https://www.abc.net.au/news/feed/2942460/rss.xml",
+    "Japan Times": "https://www.japantimes.co.jp/feed/",
+    "The Hindu": "https://www.thehindu.com/news/national/feeder/default.rss",
+    "SCMP": "https://www.scmp.com/rss/91/feed",
+    "Der Spiegel": "https://www.spiegel.de/international/index.rss",
+    # Culture & Ideas
+    "Guardian Culture": "https://www.theguardian.com/culture/rss",
+    "Aeon": "https://aeon.co/feed.rss",
+    "Smithsonian": "https://www.smithsonianmag.com/rss/latest_articles/",
+    "The Marginalian": "https://www.themarginalian.org/feed/",
+    "Nautilus": "https://nautil.us/feed/",
+    "Wired": "https://www.wired.com/feed/rss",
+    "The Conversation": "https://theconversation.com/us/articles.atom",
+    "Longreads": "https://longreads.com/feed/",
+    "Literary Hub": "https://lithub.com/feed/",
+    "Atlas Obscura": "https://www.atlasobscura.com/feeds/latest",
+}
+
+# ─── GLYPHS ───────────────────────────────────────────────
+GLITCH = "░▒▓█▌▐╌╍╎╏┃┆┇┊┋"
+KATA = "ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾃﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ"
+
+# ─── FONT RENDERING (OTF → terminal blocks) ─────────────
+_FONT_PATH = "/Users/genejohnson/Documents/CS Bishop Drawn/CSBishopDrawn-Italic.otf"
+_FONT_OBJ = None
+_FONT_SZ = 60
+_RENDER_H = 8          # terminal rows per rendered text line
+
+# Non-Latin scripts → macOS system fonts
+_SCRIPT_FONTS = {
+    'zh-cn': '/System/Library/Fonts/STHeiti Medium.ttc',
+    'ja':    '/System/Library/Fonts/ヒラギノ角ゴシック W9.ttc',
+    'ko':    '/System/Library/Fonts/AppleSDGothicNeo.ttc',
+    'ru':    '/System/Library/Fonts/Supplemental/Arial.ttf',
+    'uk':    '/System/Library/Fonts/Supplemental/Arial.ttf',
+    'el':    '/System/Library/Fonts/Supplemental/Arial.ttf',
+    'he':    '/System/Library/Fonts/Supplemental/Arial.ttf',
+    'ar':    '/System/Library/Fonts/GeezaPro.ttc',
+    'fa':    '/System/Library/Fonts/GeezaPro.ttc',
+    'hi':    '/System/Library/Fonts/Kohinoor.ttc',
+    'th':    '/System/Library/Fonts/ThonburiUI.ttc',
+}
+_FONT_CACHE = {}
+_NO_UPPER = {'zh-cn', 'ja', 'ko', 'ar', 'fa', 'hi', 'th', 'he'}
+# Left → right gradient: white-hot leading edge fades to near-black
+_GRAD_COLS = [
+    "\033[1;38;5;231m",  # white
+    "\033[1;38;5;195m",  # pale cyan-white
+    "\033[38;5;123m",   # bright cyan
+    "\033[38;5;118m",   # bright lime
+    "\033[38;5;82m",    # lime
+    "\033[38;5;46m",    # bright green
+    "\033[38;5;40m",    # green
+    "\033[38;5;34m",    # medium green
+    "\033[38;5;28m",    # dark green
+    "\033[38;5;22m",    # deep green
+    "\033[2;38;5;22m",  # dim deep green
+    "\033[2;38;5;235m", # near black
+]
+
+
+def _font():
+    """Lazy-load the OTF font."""
+    global _FONT_OBJ
+    if _FONT_OBJ is None:
+        _FONT_OBJ = ImageFont.truetype(_FONT_PATH, _FONT_SZ)
+    return _FONT_OBJ
+
+
+def _font_for_lang(lang=None):
+    """Get appropriate font for a language."""
+    if lang is None or lang not in _SCRIPT_FONTS:
+        return _font()
+    if lang not in _FONT_CACHE:
+        try:
+            _FONT_CACHE[lang] = ImageFont.truetype(_SCRIPT_FONTS[lang], _FONT_SZ)
+        except Exception:
+            _FONT_CACHE[lang] = _font()
+    return _FONT_CACHE[lang]
+
+# ─── HELPERS ──────────────────────────────────────────────
+class _Strip(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self._t = []
+
+    def handle_data(self, d):
+        self._t.append(d)
+
+    def text(self):
+        return "".join(self._t).strip()
+
+
+def strip_tags(html):
+    s = _Strip()
+    s.feed(unescape(html or ""))
+    return s.text()
+
+
+def tw():
+    try:
+        return os.get_terminal_size().columns
+    except Exception:
+        return 80
+
+
+def th():
+    try:
+        return os.get_terminal_size().lines
+    except Exception:
+        return 24
+
+
+def noise(w):
+    d = random.choice([0.15, 0.25, 0.35, 0.12])  # was [0.08, 0.12, 0.2, 0.05], now much denser
+    return "".join(
+        f"{random.choice([G_LO, G_DIM, C_DIM, W_GHOST])}"
+        f"{random.choice(GLITCH + KATA)}{RST}"
+        if random.random() < d
+        else " "
+        for _ in range(w)
+    )
+
+
+def glitch_bar(w):
+    c = random.choice(["░", "▒", "─", "╌"])
+    n = random.randint(3, w // 2)
+    o = random.randint(0, w - n)
+    return " " * o + f"{G_LO}{DIM}" + c * n + RST
+
+
+# ─── SOURCE → LANGUAGE MAPPING ──────────────────────────
+# Headlines from these outlets render in their cultural home language
+# regardless of content, reflecting the true distribution of sources.
+SOURCE_LANGS = {
+    "Der Spiegel":  "de",
+    "DW":           "de",
+    "France24":     "fr",
+    "Japan Times":  "ja",
+    "The Hindu":    "hi",
+    "SCMP":         "zh-cn",
+    "Al Jazeera":   "ar",
+}
+
+# ─── LOCATION → LANGUAGE ─────────────────────────────────
+_LOCATION_LANGS = {
+    r'\b(?:china|chinese|beijing|shanghai|hong kong|xi jinping)\b': 'zh-cn',
+    r'\b(?:japan|japanese|tokyo|osaka|kishida)\b': 'ja',
+    r'\b(?:korea|korean|seoul|pyongyang)\b': 'ko',
+    r'\b(?:russia|russian|moscow|kremlin|putin)\b': 'ru',
+    r'\b(?:saudi|dubai|qatar|egypt|cairo|arabic)\b': 'ar',
+    r'\b(?:india|indian|delhi|mumbai|modi)\b': 'hi',
+    r'\b(?:germany|german|berlin|munich|scholz)\b': 'de',
+    r'\b(?:france|french|paris|lyon|macron)\b': 'fr',
+    r'\b(?:spain|spanish|madrid)\b': 'es',
+    r'\b(?:italy|italian|rome|milan|meloni)\b': 'it',
+    r'\b(?:portugal|portuguese|lisbon)\b': 'pt',
+    r'\b(?:brazil|brazilian|são paulo|lula)\b': 'pt',
+    r'\b(?:greece|greek|athens)\b': 'el',
+    r'\b(?:turkey|turkish|istanbul|ankara|erdogan)\b': 'tr',
+    r'\b(?:iran|iranian|tehran)\b': 'fa',
+    r'\b(?:thailand|thai|bangkok)\b': 'th',
+    r'\b(?:vietnam|vietnamese|hanoi)\b': 'vi',
+    r'\b(?:ukraine|ukrainian|kyiv|kiev|zelensky)\b': 'uk',
+    r'\b(?:israel|israeli|jerusalem|tel aviv|netanyahu)\b': 'he',
+}
+
+_TRANSLATE_CACHE = {}
+
+
+def _detect_location_language(title):
+    """Detect if headline mentions a location, return target language."""
+    title_lower = title.lower()
+    for pattern, lang in _LOCATION_LANGS.items():
+        if re.search(pattern, title_lower):
+            return lang
+    return None
+
+
+def _translate_headline(title, target_lang):
+    """Translate headline via Google Translate API (zero dependencies)."""
+    key = (title, target_lang)
+    if key in _TRANSLATE_CACHE:
+        return _TRANSLATE_CACHE[key]
+    try:
+        q = urllib.parse.quote(title)
+        url = ("https://translate.googleapis.com/translate_a/single"
+               f"?client=gtx&sl=en&tl={target_lang}&dt=t&q={q}")
+        req = urllib.request.Request(url, headers={"User-Agent": "mainline/0.1"})
+        resp = urllib.request.urlopen(req, timeout=5)
+        data = json.loads(resp.read())
+        result = "".join(p[0] for p in data[0] if p[0]) or title
+    except Exception:
+        result = title
+    _TRANSLATE_CACHE[key] = result
+    return result
+
+# ─── CONTENT FILTER ───────────────────────────────────────
+_SKIP_RE = re.compile(
+    r'\b(?:'
+    # ── sports ──
+    r'football|soccer|basketball|baseball|softball|tennis|golf|cricket|rugby|'
+    r'hockey|lacrosse|volleyball|badminton|'
+    r'nba|nfl|nhl|mlb|mls|fifa|uefa|'
+    r'premier league|champions league|la liga|serie a|bundesliga|'
+    r'world cup|super bowl|world series|stanley cup|'
+    r'playoff|playoffs|touchdown|goalkeeper|striker|quarterback|'
+    r'slam dunk|home run|grand slam|offside|halftime|'
+    r'batting|wicket|innings|'
+    r'formula 1|nascar|motogp|'
+    r'boxing|ufc|mma|'
+    r'marathon|tour de france|'
+    r'transfer window|draft pick|relegation|'
+    # ── vapid / insipid ──
+    r'kardashian|jenner|reality tv|reality show|'
+    r'influencer|viral video|tiktok|instagram|'
+    r'best dressed|worst dressed|red carpet|'
+    r'horoscope|zodiac|gossip|bikini|selfie|'
+    r'you won.t believe|what happened next|'
+    r'celebrity couple|celebrity feud|baby bump'
+    r')\b',
+    re.IGNORECASE
+)
+
+
+def _skip(title):
+    """Return True if headline is sports, vapid, or insipid."""
+    return bool(_SKIP_RE.search(title))
+
+
+# ─── DISPLAY ──────────────────────────────────────────────
+def type_out(text, color=G_HI):
+    i = 0
+    while i < len(text):
+        if random.random() < 0.3:
+            b = random.randint(2, 5)
+            sys.stdout.write(f"{color}{text[i:i+b]}{RST}")
+            i += b
+        else:
+            sys.stdout.write(f"{color}{text[i]}{RST}")
+            i += 1
+        sys.stdout.flush()
+        time.sleep(random.uniform(0.004, 0.018))
+
+
+def slow_print(text, color=G_DIM, delay=0.015):
+    for ch in text:
+        sys.stdout.write(f"{color}{ch}{RST}")
+        sys.stdout.flush()
+        time.sleep(delay)
+
+
+def boot_ln(label, status, ok=True):
+    dots = max(3, min(30, tw() - len(label) - len(status) - 8))
+    sys.stdout.write(f"  {G_DIM}>{RST} {W_DIM}{label} ")
+    sys.stdout.flush()
+    for _ in range(dots):
+        sys.stdout.write(f"{G_LO}.")
+        sys.stdout.flush()
+        time.sleep(random.uniform(0.006, 0.025))
+    c = G_MID if ok else "\033[2;38;5;196m"
+    print(f" {c}{status}{RST}")
+    time.sleep(random.uniform(0.02, 0.1))
+
+
+# ─── FETCH ────────────────────────────────────────────────
+def fetch_feed(url):
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "mainline/0.1"})
+        resp = urllib.request.urlopen(req, timeout=FEED_TIMEOUT)
+        return feedparser.parse(resp.read())
+    except Exception:
+        return None
+
+
+def fetch_all():
+    items = []
+    linked = failed = 0
+    for src, url in FEEDS.items():
+        feed = fetch_feed(url)
+        if feed is None or (feed.bozo and not feed.entries):
+            boot_ln(src, "DARK", False)
+            failed += 1
+            continue
+        n = 0
+        for e in feed.entries:
+            t = strip_tags(e.get("title", ""))
+            if not t or _skip(t):
+                continue
+            pub = e.get("published_parsed") or e.get("updated_parsed")
+            try:
+                ts = datetime(*pub[:6]).strftime("%H:%M") if pub else "——:——"
+            except Exception:
+                ts = "——:——"
+            items.append((t, src, ts))
+            n += 1
+        if n:
+            boot_ln(src, f"LINKED [{n}]", True)
+            linked += 1
+        else:
+            boot_ln(src, "EMPTY", False)
+            failed += 1
+    return items, linked, failed
+
+
+def _fetch_gutenberg(url, label):
+    """Download and parse stanzas/passages from a Project Gutenberg text."""
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "mainline/0.1"})
+        resp = urllib.request.urlopen(req, timeout=15)
+        text = resp.read().decode('utf-8', errors='replace').replace('\r\n', '\n').replace('\r', '\n')
+        # Strip PG boilerplate
+        m = re.search(r'\*\*\*\s*START OF[^\n]*\n', text)
+        if m:
+            text = text[m.end():]
+        m = re.search(r'\*\*\*\s*END OF', text)
+        if m:
+            text = text[:m.start()]
+        # Split on blank lines into stanzas/passages
+        blocks = re.split(r'\n{2,}', text.strip())
+        items = []
+        for blk in blocks:
+            blk = ' '.join(blk.split())   # flatten to one line
+            if len(blk) < 20 or len(blk) > 280:
+                continue
+            if blk.isupper():             # skip all-caps headers
+                continue
+            if re.match(r'^[IVXLCDM]+\.?\s*$', blk):  # roman numerals
+                continue
+            items.append((blk, label, ''))
+        return items
+    except Exception:
+        return []
+
+
+def fetch_poetry():
+    """Fetch all poetry/literature sources."""
+    items = []
+    linked = failed = 0
+    for label, url in POETRY_SOURCES.items():
+        stanzas = _fetch_gutenberg(url, label)
+        if stanzas:
+            boot_ln(label, f"LOADED [{len(stanzas)}]", True)
+            items.extend(stanzas)
+            linked += 1
+        else:
+            boot_ln(label, "DARK", False)
+            failed += 1
+    return items, linked, failed
+
+
+# ─── STREAM ───────────────────────────────────────────────
+_SCROLL_DUR = 3.75  # seconds per headline
+_mic_db = -99.0     # current mic level, written by background thread
+_mic_stream = None
+
+
+def _start_mic():
+    """Start background mic monitoring; silently skipped if unavailable."""
+    global _mic_db, _mic_stream
+    if not _HAS_MIC:
+        return
+    def _cb(indata, frames, t, status):
+        global _mic_db
+        rms = float(_np.sqrt(_np.mean(indata ** 2)))
+        _mic_db = 20 * _np.log10(rms) if rms > 0 else -99.0
+    try:
+        _mic_stream = _sd.InputStream(
+            callback=_cb, channels=1, samplerate=44100, blocksize=2048)
+        _mic_stream.start()
+        atexit.register(lambda: _mic_stream.stop() if _mic_stream else None)
+        return True
+    except Exception:
+        return False
+
+
+def _render_line(text, font=None):
+    """Render a line of text as terminal rows using OTF font + half-blocks."""
+    if font is None:
+        font = _font()
+    bbox = font.getbbox(text)
+    if not bbox or bbox[2] <= bbox[0]:
+        return [""]
+    pad = 4
+    img_w = bbox[2] - bbox[0] + pad * 2
+    img_h = bbox[3] - bbox[1] + pad * 2
+    img = Image.new('L', (img_w, img_h), 0)
+    draw = ImageDraw.Draw(img)
+    draw.text((-bbox[0] + pad, -bbox[1] + pad), text, fill=255, font=font)
+    pix_h = _RENDER_H * 2
+    scale = pix_h / max(img_h, 1)
+    new_w = max(1, int(img_w * scale))
+    img = img.resize((new_w, pix_h), Image.Resampling.LANCZOS)
+    data = img.tobytes()
+    thr = 80
+    rows = []
+    for y in range(0, pix_h, 2):
+        row = []
+        for x in range(new_w):
+            top = data[y * new_w + x] > thr
+            bot = data[(y + 1) * new_w + x] > thr if y + 1 < pix_h else False
+            if top and bot:
+                row.append("█")
+            elif top:
+                row.append("▀")
+            elif bot:
+                row.append("▄")
+            else:
+                row.append(" ")
+        rows.append("".join(row))
+    while rows and not rows[-1].strip():
+        rows.pop()
+    while rows and not rows[0].strip():
+        rows.pop(0)
+    return rows if rows else [""]
+
+
+def _big_wrap(text, max_w, font=None):
+    """Word-wrap text and render with OTF font."""
+    if font is None:
+        font = _font()
+    words = text.split()
+    lines, cur = [], ""
+    for word in words:
+        test = f"{cur} {word}".strip() if cur else word
+        bbox = font.getbbox(test)
+        if bbox:
+            img_h = bbox[3] - bbox[1] + 8
+            pix_h = _RENDER_H * 2
+            scale = pix_h / max(img_h, 1)
+            term_w = int((bbox[2] - bbox[0] + 8) * scale)
+        else:
+            term_w = 0
+        if term_w > max_w - 4 and cur:
+            lines.append(cur)
+            cur = word
+        else:
+            cur = test
+    if cur:
+        lines.append(cur)
+    out = []
+    for i, ln in enumerate(lines):
+        out.extend(_render_line(ln, font))
+        if i < len(lines) - 1:
+            out.append("")
+    return out
+
+
+def _lr_gradient(rows):
+    """Color each non-space block character with a left-to-right gradient."""
+    n = len(_GRAD_COLS)
+    max_x = max((len(r.rstrip()) for r in rows if r.strip()), default=1)
+    out = []
+    for row in rows:
+        if not row.strip():
+            out.append(row)
+            continue
+        buf = []
+        for x, ch in enumerate(row):
+            if ch == ' ':
+                buf.append(' ')
+            else:
+                idx = min(round(x / max(max_x - 1, 1) * (n - 1)), n - 1)
+                buf.append(f"{_GRAD_COLS[idx]}{ch}\033[0m")
+        out.append("".join(buf))
+    return out
+
+
+def _fade_line(s, fade):
+    """Dissolve a rendered line by probabilistically dropping characters."""
+    if fade >= 1.0:
+        return s
+    if fade <= 0.0:
+        return ''
+    result = []
+    i = 0
+    while i < len(s):
+        if s[i] == '\033' and i + 1 < len(s) and s[i + 1] == '[':
+            j = i + 2
+            while j < len(s) and not s[j].isalpha():
+                j += 1
+            result.append(s[i:j + 1])
+            i = j + 1
+        elif s[i] == ' ':
+            result.append(' ')
+            i += 1
+        else:
+            result.append(s[i] if random.random() < fade else ' ')
+            i += 1
+    return ''.join(result)
+
+
+def _vis_trunc(s, w):
+    """Truncate string to visual width w, skipping ANSI escape codes."""
+    result = []
+    vw = 0
+    i = 0
+    while i < len(s):
+        if vw >= w:
+            break
+        if s[i] == '\033' and i + 1 < len(s) and s[i + 1] == '[':
+            j = i + 2
+            while j < len(s) and not s[j].isalpha():
+                j += 1
+            result.append(s[i:j + 1])
+            i = j + 1
+        else:
+            result.append(s[i])
+            vw += 1
+            i += 1
+    return ''.join(result)
+
+
+def _next_headline(pool, items, seen):
+    """Pull the next unique headline from pool, refilling as needed."""
+    while True:
+        if not pool:
+            pool.extend(items)
+            random.shuffle(pool)
+            seen.clear()
+        title, src, ts = pool.pop()
+        sig = title.lower().strip()
+        if sig not in seen:
+            seen.add(sig)
+            return title, src, ts
+
+
+def _make_block(title, src, ts, w):
+    """Render a headline into a content block with color."""
+    target_lang = (SOURCE_LANGS.get(src) or _detect_location_language(title)) if MODE == 'news' else None
+    lang_font = _font_for_lang(target_lang)
+    if target_lang:
+        title = _translate_headline(title, target_lang)
+    # Don't uppercase scripts that have no case (CJK, Arabic, etc.)
+    if target_lang and target_lang in _NO_UPPER:
+        title_up = re.sub(r"\s+", " ", title)
+    else:
+        title_up = re.sub(r"\s+", " ", title.upper())
+    for old, new in [("\u2019","'"), ("\u2018","'"), ("\u201c",'"'),
+                     ("\u201d",'"'), ("\u2013","-"), ("\u2014","-")]:
+        title_up = title_up.replace(old, new)
+    big_rows = _big_wrap(title_up, w - 4, lang_font)
+    big_rows = _lr_gradient(big_rows)
+    hc = random.choice([
+        "\033[38;5;46m",   # matrix green
+        "\033[38;5;34m",   # dark green
+        "\033[38;5;82m",   # lime
+        "\033[38;5;48m",   # sea green
+        "\033[38;5;37m",   # teal
+        "\033[38;5;44m",   # cyan
+        "\033[38;5;87m",   # sky
+        "\033[38;5;117m",  # ice blue
+        "\033[38;5;250m",  # cool white
+        "\033[38;5;156m",  # pale green
+        "\033[38;5;120m",  # mint
+        "\033[38;5;80m",   # dark cyan
+        "\033[38;5;108m",  # grey-green
+        "\033[38;5;115m",  # sage
+        "\033[1;38;5;46m", # bold green
+        "\033[1;38;5;250m",# bold white
+    ])
+    content = ["  " + r for r in big_rows]
+    content.append("")
+    meta = f"\u2591 {src} \u00b7 {ts}"
+    content.append(" " * max(2, w - len(meta) - 2) + meta)
+    return content, hc, len(content) - 1  # (rows, color, meta_row_index)
+
+
+def stream(items):
+    random.shuffle(items)
+    pool = list(items)
+    seen = set()
+    queued = 0
+
+    time.sleep(0.5)
+    sys.stdout.write(CLR)
+    sys.stdout.flush()
+
+    w, h = tw(), th()
+    GAP = 3            # blank rows between headlines
+    dt = _SCROLL_DUR / (h + 15) * 2  # 2x slower scroll
+
+    # active blocks: (content_rows, color, canvas_y, meta_idx)
+    active = []
+    cam = 0            # viewport top in virtual canvas coords
+    next_y = h         # canvas-y where next block starts (off-screen bottom)
+    noise_cache = {}
+
+    def _noise_at(cy):
+        if cy not in noise_cache:
+            noise_cache[cy] = noise(w) if random.random() < 0.15 else None
+        return noise_cache[cy]
+
+    while queued < HEADLINE_LIMIT or active:
+        w, h = tw(), th()
+
+        # Enqueue new headlines when room at the bottom
+        while next_y < cam + h + 10 and queued < HEADLINE_LIMIT:
+            t, src, ts = _next_headline(pool, items, seen)
+            content, hc, midx = _make_block(t, src, ts, w)
+            active.append((content, hc, next_y, midx))
+            next_y += len(content) + GAP
+            queued += 1
+
+        # Draw frame
+        top_zone = max(1, int(h * 0.25))  # 25% fade zone at top (exit)
+        bot_zone = max(1, int(h * 0.10))  # 10% fade zone at bottom (entry)
+        buf = []
+        for r in range(h):
+            cy = cam + r
+            row_fade = min(1.0, min(r / top_zone, (h - 1 - r) / bot_zone))
+            drawn = False
+            for content, hc, by, midx in active:
+                cr = cy - by
+                if 0 <= cr < len(content):
+                    ln = _vis_trunc(content[cr], w)
+                    if row_fade < 1.0:
+                        ln = _fade_line(ln, row_fade)
+                    if cr == midx:
+                        buf.append(f"\033[{r+1};1H{W_COOL}{ln}{RST}\033[K")
+                    elif ln.strip():
+                        buf.append(f"\033[{r+1};1H{hc}{ln}{RST}\033[K")
+                    else:
+                        buf.append(f"\033[{r+1};1H\033[K")
+                    drawn = True
+                    break
+            if not drawn:
+                n = _noise_at(cy)
+                if row_fade < 1.0 and n:
+                    n = _fade_line(n, row_fade)
+                if n:
+                    buf.append(f"\033[{r+1};1H{n}")
+                else:
+                    buf.append(f"\033[{r+1};1H\033[K")
+
+        # Glitch — base rate + mic-reactive spikes
+        mic_excess = max(0.0, _mic_db - MIC_THRESHOLD_DB)
+        glitch_prob = 0.32 + min(0.9, mic_excess * 0.16)
+        n_hits = 4 + int(mic_excess / 2)
+        if random.random() < glitch_prob and buf:
+            for _ in range(min(n_hits, h)):
+                gi = random.randint(0, len(buf) - 1)
+                buf[gi] = f"\033[{gi+1};1H{glitch_bar(w)}"
+
+        sys.stdout.write("".join(buf))
+        sys.stdout.flush()
+        time.sleep(dt)
+
+        # Advance viewport
+        cam += 1
+
+        # Prune off-screen blocks and stale noise
+        active = [(c, hc, by, mi) for c, hc, by, mi in active
+                  if by + len(c) > cam]
+        for k in list(noise_cache):
+            if k < cam:
+                del noise_cache[k]
+
+    sys.stdout.write(CLR)
+    sys.stdout.flush()
+
+
+# ─── MAIN ─────────────────────────────────────────────────
+TITLE = [
+    "  ███╗   ███╗ █████╗ ██╗███╗   ██╗██╗     ██╗███╗   ██╗███████╗",
+    "  ████╗ ████║██╔══██╗██║████╗  ██║██║     ██║████╗  ██║██╔════╝",
+    "  ██╔████╔██║███████║██║██╔██╗ ██║██║     ██║██╔██╗ ██║█████╗  ",
+    "  ██║╚██╔╝██║██╔══██║██║██║╚██╗██║██║     ██║██║╚██╗██║██╔══╝  ",
+    "  ██║ ╚═╝ ██║██║  ██║██║██║ ╚████║███████╗██║██║ ╚████║███████╗",
+    "  ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝╚══════╝╚═╝╚═╝  ╚═══╝╚══════╝",
+]
+
+
+def main():
+    atexit.register(lambda: print(CURSOR_ON, end="", flush=True))
+
+    def handle_sigint(*_):
+        print(f"\n\n  {G_DIM}> SIGNAL LOST{RST}")
+        print(f"  {W_GHOST}> connection terminated{RST}\n")
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, handle_sigint)
+
+    w = tw()
+    print(CLR, end="")
+    print(CURSOR_OFF, end="")
+    print()
+    time.sleep(0.4)
+
+    for ln in TITLE:
+        print(f"{G_HI}{ln}{RST}")
+        time.sleep(0.07)
+
+    print()
+    _subtitle = "literary consciousness stream" if MODE == 'poetry' else "digital consciousness stream"
+    print(f"  {W_DIM}v0.1 · {_subtitle}{RST}")
+    print(f"  {W_GHOST}{'─' * (w - 4)}{RST}")
+    print()
+    time.sleep(0.4)
+
+    if MODE == 'poetry':
+        slow_print("  > INITIALIZING LITERARY CORPUS...\n")
+        time.sleep(0.2)
+        print()
+        items, linked, failed = fetch_poetry()
+        print()
+        print(f"  {G_DIM}>{RST} {G_MID}{linked} TEXTS LOADED{RST} {W_GHOST}· {failed} DARK{RST}")
+        print(f"  {G_DIM}>{RST} {G_MID}{len(items)} STANZAS ACQUIRED{RST}")
+    else:
+        slow_print("  > INITIALIZING FEED ARRAY...\n")
+        time.sleep(0.2)
+        print()
+        items, linked, failed = fetch_all()
+        print()
+        print(f"  {G_DIM}>{RST} {G_MID}{linked} SOURCES LINKED{RST} {W_GHOST}· {failed} DARK{RST}")
+        print(f"  {G_DIM}>{RST} {G_MID}{len(items)} SIGNALS ACQUIRED{RST}")
+
+    if not items:
+        print(f"\n  {W_DIM}> NO SIGNAL — check network{RST}")
+        sys.exit(1)
+
+    print()
+    mic_ok = _start_mic()
+    if _HAS_MIC:
+        boot_ln("Microphone", "ACTIVE" if mic_ok else "OFFLINE · check System Settings → Privacy → Microphone", mic_ok)
+
+    time.sleep(0.4)
+    slow_print("  > STREAMING...\n")
+    time.sleep(0.2)
+    print(f"  {W_GHOST}{'─' * (w - 4)}{RST}")
+    print()
+    time.sleep(0.4)
+
+    stream(items)
+
+    print()
+    print(f"  {W_GHOST}{'─' * (tw() - 4)}{RST}")
+    print(f"  {G_DIM}> {HEADLINE_LIMIT} SIGNALS PROCESSED{RST}")
+    print(f"  {W_GHOST}> end of stream{RST}")
+    print()
+
+
+if __name__ == "__main__":
+    main()