Forever Housekeeping: Piper TTS Speech Hygiene, Kramdown MathJax Healing, and the Tool Roll

On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean

GIT repo clean. Take BEFORE reading, make CHANGE, record AFTER diff.
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'remotes/honeybot/scripts/content_loader.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'remotes/honeybot/scripts/content_loader.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'remotes/honeybot/scripts/content_loader.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'remotes/honeybot/scripts/content_loader.py'.
(nix) pipulate $ d
diff --git a/remotes/honeybot/scripts/content_loader.py b/remotes/honeybot/scripts/content_loader.py
index 8aa4950..5b6232c 100644
--- a/remotes/honeybot/scripts/content_loader.py
+++ b/remotes/honeybot/scripts/content_loader.py
@@ -274,6 +274,162 @@ def get_playlist(recent_n=10, include_archive=True):
         print(f"Librarian Error: {e}", file=sys.stderr)
         return []
 
+_TEX_SPOKEN_MAP = (
+    (r'\\(?:long)?rightarrow\b|\\to\b|\\(?:Long)?Rightarrow\b', ' right arrow '),
+    (r'\\(?:long)?leftarrow\b|\\(?:Long)?Leftarrow\b', ' left arrow '),
+    (r'\\(?:long)?leftrightarrow\b|\\(?:Long)?Leftrightarrow\b|\\iff\b', ' left right arrow '),
+    (r'\\times\b', ' times '),
+    (r'\\cdot\b', ' dot '),
+    (r'\\(?:le|leq)\b', ' less than or equal to '),
+    (r'\\(?:ge|geq)\b', ' greater than or equal to '),
+    (r'\\(?:ne|neq)\b', ' not equal to '),
+    (r'\\approx\b', ' approximately '),
+    (r'\\infty\b', ' infinity '),
+    (r'\\pm\b', ' plus or minus '),
+    (r'\\Sigma\b|\\sum\b', ' sum '),
+    (r'\\Delta\b', ' delta '),
+)
+
+_KNOWN_DOMAIN_DIRS = frozenset({
+    "mikelev.in", "qamy.ai", "npvg.org", "levinix.org", "levinix.com",
+    "levinux.com", "sunpug.io", "guerillatech.com", "rfc9110.org",
+    "rfc9111.io", "rfc9111.com", "pipulate.com",
+})
+
+_FILEPATH_RE = re.compile(
+    r'(?<![:\w])'
+    r'(?:'
+    r'(?:~|\.{1,2})?(?:/\.?[A-Za-z0-9_~-]+(?:\.[A-Za-z0-9_-]+)*){2,}/?'
+    r'|\b[A-Za-z0-9_~-]+(?:\.[A-Za-z0-9_-]+)*(?:/\.?[A-Za-z0-9_~-]+(?:\.[A-Za-z0-9_-]+)*){2,}/?'
+    r'|\b[A-Za-z0-9_~-]+(?:\.[A-Za-z0-9_-]+)*/\.?[A-Za-z0-9_~-]+\.[A-Za-z0-9]{1,10}\b'
+    r')'
+)
+
+
+def _truncate_after_editorial_take(text):
+    """Keep the article through 'Ai/AI Editorial Take' and drop subsequent Book Analysis sections."""
+    m_take = re.search(
+        r'^#{1,6}[ \t]*ai[ \t]+editorial[ \t]+take\b[^\n]*\n',
+        text,
+        flags=re.IGNORECASE | re.MULTILINE,
+    )
+    if m_take:
+        m_next = re.search(r'^#{1,6}[ \t]', text[m_take.end():], flags=re.MULTILINE)
+        if m_next:
+            text = text[: m_take.end() + m_next.start()]
+    m_tweet = re.search(
+        r'^#{1,6}[ \t]*(?:🐦[ \t]*)?x\.com[ \t]+promo[ \t]+tweet\b',
+        text,
+        flags=re.IGNORECASE | re.MULTILINE,
+    )
+    if m_tweet:
+        text = text[: m_tweet.start()]
+    return text
+
+
+def _humanize_tex_expr(expr):
+    """Convert inner TeX/MathJax math into natural speech without dollar signs or raw backslashes."""
+    s = expr.strip()
+    s = re.sub(r'\\frac\{([^{}]*)\}\{([^{}]*)\}', r' \1 over \2 ', s)
+    s = re.sub(r'\\(?:text|mathrm|mathbf|mathcal|mathit|texttt|operatorname)\{([^{}]*)\}', r'\1', s)
+    for pat, repl in _TEX_SPOKEN_MAP:
+        s = re.sub(pat, repl, s)
+    s = re.sub(r'\\([A-Za-z]+)', r' \1 ', s)
+    s = s.replace('{', ' ').replace('}', ' ')
+    s = re.sub(r'\s+', ' ', s).strip()
+    return f" {s} " if s else " "
+
+
+def _is_single_dollar_mathjax(masked_line, s_pos, e_pos):
+    """Port of init.lua's is_mathjax_span: true when $...$ is TeX/MathJax, false for currency/shell."""
+    expr = masked_line[s_pos + 1 : e_pos]
+    if not (1 <= len(expr) <= 120):
+        return False
+    if expr[0].isspace() or expr[-1].isspace():
+        return False
+    prev_ch = masked_line[s_pos - 1] if s_pos > 0 else ""
+    next_ch = masked_line[e_pos + 1] if e_pos + 1 < len(masked_line) else ""
+    if prev_ch and (prev_ch.isalnum() or prev_ch in "\\$"):
+        return False
+    if next_ch and (next_ch.isalnum() or next_ch == "$"):
+        return False
+    if re.match(r"^\d[\d,.]*/[A-Za-z]{2,}", expr) or re.match(r"^\d[\d,.]*[kKmMbB]?\s+[A-Za-z]{2,}", expr):
+        return False
+    if "\\" in expr:
+        return True
+    if re.search(r"[\^_=<>&+]", expr):
+        return True
+    if re.match(r"^(?:[A-Za-z]'?|\d+/\d+|[A-Za-z]/[A-Za-z])$", expr):
+        return True
+    if re.match(r"^[A-Za-z]+\([^()]*\)$", expr):
+        return True
+    if re.match(r"^[A-Za-z0-9_]+\s*[-+*/]\s*[A-Za-z0-9_]+$", expr):
+        return True
+    return False
+
+
+def _strip_single_dollar_mathjax_line(line):
+    """Unwrap single-dollar MathJax spans on a single line while preserving currency and inline code."""
+    if '$' not in line:
+        return line
+    shadow = re.sub(r'`+[^`]*`+', lambda m: '#' * len(m.group(0)), line)
+    shadow = re.sub(r'\$\$+', lambda m: '#' * len(m.group(0)), shadow)
+    positions = [m.start() for m in re.finditer(r'\$', shadow)]
+    if len(positions) < 2:
+        return line
+    matches = []
+    idx = 0
+    while idx + 1 < len(positions):
+        s_pos, e_pos = positions[idx], positions[idx + 1]
+        if _is_single_dollar_mathjax(shadow, s_pos, e_pos):
+            matches.append((s_pos, e_pos))
+            idx += 2
+        else:
+            idx += 1
+    if not matches:
+        return line
+    out = []
+    cursor = 0
+    for s_pos, e_pos in matches:
+        out.append(line[cursor:s_pos])
+        out.append(_humanize_tex_expr(line[s_pos + 1 : e_pos]))
+        cursor = e_pos + 1
+    out.append(line[cursor:])
+    return "".join(out)
+
+
+def _strip_mathjax_for_tts(text):
+    """Strip $$...$$ and collision-safe $...$ MathJax delimiters and humanize TeX for Piper TTS."""
+    text = re.sub(r'\$\$([\s\S]+?)\$\$', lambda m: _humanize_tex_expr(m.group(1)), text)
+    text = re.sub(r'\\\(([\s\S]+?)\\\)', lambda m: _humanize_tex_expr(m.group(1)), text)
+    text = re.sub(r'\\\[([\s\S]+?)\\\]', lambda m: _humanize_tex_expr(m.group(1)), text)
+    return "\n".join(_strip_single_dollar_mathjax_line(ln) for ln in text.splitlines())
+
+
+def _simplify_filepath_match(match):
+    """Speak the filename with extension if present, else collapse multi-slash paths to 'file path'."""
+    raw = match.group(0)
+    clean = raw.rstrip('/')
+    segments = [seg for seg in clean.split('/') if seg]
+    if not segments:
+        return raw
+    if all(seg.isdigit() for seg in segments):
+        return raw
+    if raw.endswith('/'):
+        return "file path"
+    basename = segments[-1]
+    if basename.lower() in _KNOWN_DOMAIN_DIRS:
+        return "file path"
+    if '.' in basename[1:] and re.match(r'^\.?[A-Za-z0-9_~-]+(?:\.[A-Za-z0-9_-]+)+$', basename):
+        return basename
+    return "file path"
+
+
+def _simplify_filepaths_for_tts(text):
+    """Replace slash-heavy filesystem paths with their filename.ext or 'file path'."""
+    return _FILEPATH_RE.sub(_simplify_filepath_match, text)
+
+
 def clean_markdown(text, label=None, census=True):
     """Sanitizes Markdown for the Piper TTS engine.
 
@@ -368,6 +524,7 @@ def clean_markdown(text, label=None, census=True):
     # Strip fenced code blocks (line-anchored first so stray inline backticks cannot
     # invert fences) and disarm backticked inline-code examples (including Vim gq
     # hard-wrapped spans) BEFORE capturing standalone live player-piano cues.
+    text = _truncate_after_editorial_take(text)
     CODE_SENTINEL = '\x00CODEBLOCK\x00'
     text = re.sub(r'^[triple backticks][^\n]*\n.*?^[triple backticks][ \t]*$', f' {CODE_SENTINEL} ', text, flags=re.MULTILINE | re.DOTALL)
     text = re.sub(r'[triple backticks].*?[triple backticks]', f' {CODE_SENTINEL} ', text, flags=re.DOTALL)
@@ -419,6 +576,9 @@ def clean_markdown(text, label=None, census=True):
         idx = text.index(spoken)
         text = text[:idx + len(spoken)] + text[idx + len(spoken):].replace(spoken, '')
 
+    # Strip $$...$$ and single-dollar $...$ MathJax before backticks and underscores are removed
+    text = _strip_mathjax_for_tts(text)
+
     # Remove Inline Code
     text = re.sub(r'`([^`]+)`', r'\1', text)
     # Remove Images
@@ -489,6 +649,8 @@ def clean_markdown(text, label=None, census=True):
 
     # Remove HTML tags
     text = re.sub(r'<[^>]+>', '', text)
+    # Simplify slash-heavy file paths to filename.ext or "file path" before stripping underscores
+    text = _simplify_filepaths_for_tts(text)
     # Remove Headers/Bold/Italic markers
     text = re.sub(r'[*_#]', '', text)
 
(nix) pipulate $ m
📝 Committing: chore: Add TeX/MathJax spoken mapping and domain directory definitions
[main 28a28f6] chore: Add TeX/MathJax spoken mapping and domain directory definitions
 1 file changed, 162 insertions(+)
(nix) pipulate $ git push
Enumerating objects: 11, done.
Counting objects: 100% (11/11), done.
Delta compression using up to 48 threads
Compressing objects: 100% (5/5), done.
Writing objects: 100% (6/6), 2.83 KiB | 2.83 MiB/s, done.
Total 6 (delta 4), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (4/4), completed with 4 local objects.
To github.com:pipulate/pipulate.git
   25544aa..28a28f6  main -> main
(nix) pipulate $ 

On branch main
Your branch is ahead of 'origin/main' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean

GIT repo clean. Take BEFORE reading, make CHANGE, record AFTER diff.
(nix) pipulate $ patch
(nix) pipulate $ app
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/sanitizer.py'.
✅ DETERMINISTIC PATCH APPLIED: Successfully mutated 'scripts/articles/sanitizer.py'.
(nix) pipulate $ d
diff --git a/scripts/articles/sanitizer.py b/scripts/articles/sanitizer.py
index 424b543..ce92c41 100644
--- a/scripts/articles/sanitizer.py
+++ b/scripts/articles/sanitizer.py
@@ -87,17 +87,28 @@ def _double_single_dollar_mathjax_line(line: str) -> tuple[str, int]:
 
 def double_single_dollar_mathjax(content: str) -> tuple[str, int]:
     """Double single-dollar MathJax spans outside fenced code blocks. Returns (new_content, count)."""
-    parts = FENCE_SEGMENT_RE.split(content)
+    lines = content.split('\n')
+    in_fence = False
+    fence_char = ""
     total = 0
-    for idx in range(0, len(parts), 2):
-        lines = parts[idx].split('\n')
-        for li, ln in enumerate(lines):
-            new_ln, n = _double_single_dollar_mathjax_line(ln)
-            if n:
-                lines[li] = new_ln
-                total += n
-        parts[idx] = '\n'.join(lines)
-    return ''.join(parts), total
+    for i, ln in enumerate(lines):
+        m_fence = re.match(r'^\s*(`{3,}|~{3,})', ln)
+        if m_fence:
+            ch = m_fence.group(1)[0]
+            if not in_fence:
+                in_fence = True
+                fence_char = ch
+            elif ch == fence_char and re.match(r'^\s*(`{3,}|~{3,})\s*$', ln):
+                in_fence = False
+                fence_char = ""
+            continue
+        if in_fence:
+            continue
+        new_ln, n = _double_single_dollar_mathjax_line(ln)
+        if n:
+            lines[i] = new_ln
+            total += n
+    return '\n'.join(lines), total
 
 
 def heal_corpus_mathjax(posts_dir: Path, dry_run: bool = False) -> tuple[int, int]:
@@ -473,7 +484,6 @@ def main():
         help="Explicit override: light lane (strip prompt boundary + IPs only; keep fences and names)."
     )
     common.add_standard_arguments(parser)
-    args = parser.parse_args()
 
     # Data-driven routing: the target's 'lane' in blogs.json decides,
     # unless an explicit flag overrides. Fail closed toward public scrub.
(nix) pipulate $ m
📝 Committing: fix: enhance mathjax span detection in sanitizer
[main 4a94fe0] fix: enhance mathjax span detection in sanitizer
 1 file changed, 21 insertions(+), 11 deletions(-)
(nix) pipulate $ git push
Enumerating objects: 16, done.
Counting objects: 100% (16/16), done.
Delta compression using up to 48 threads
Compressing objects: 100% (11/11), done.
Writing objects: 100% (11/11), 2.83 KiB | 2.83 MiB/s, done.
Total 11 (delta 9), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (9/9), completed with 5 local objects.
To github.com:pipulate/pipulate.git
   28a28f6..4a94fe0  main -> main
(nix) pipulate $ 

On branch main
Your branch is ahead of 'home/main' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean

GIT repo clean. Take BEFORE reading, make CHANGE, record AFTER diff.
(nix) trimnoir $ git status
On branch main
Your branch is ahead of 'home/main' by 1 commit.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean
(nix) trimnoir $ git --no-pager diff
diff --git a/_posts/2025-06-24-philosophy-axioms-ai-consciousness-stress-test.md b/_posts/2025-06-24-philosophy-axioms-ai-consciousness-stress-test.md
index 92a7c945b..505c1e7f1 100644
--- a/_posts/2025-06-24-philosophy-axioms-ai-consciousness-stress-test.md
+++ b/_posts/2025-06-24-philosophy-axioms-ai-consciousness-stress-test.md
@@ -138,8 +138,8 @@ Solipsism is the philosophical idea that only one's own mind is sure to exist. T
 #### 5. Gödel's Incompleteness Theorems
 These are two landmark theorems in mathematical logic, published by Kurt Gödel in 1931. They shattered the dream of creating a complete and consistent mathematical system.
 
-* **First Incompleteness Theorem:** In any consistent formal axiomatic system $F$ powerful enough to describe basic arithmetic, there exist statements that are true but cannot be *proven* within that system. In essence, **Truth is more powerful than Provability**.
-* **Second Incompleteness Theorem:** Such a system $F$ cannot prove its own consistency. To be certain the system is free of contradictions, you must use a more powerful, external system, which in turn cannot prove its own consistency.
+* **First Incompleteness Theorem:** In any consistent formal axiomatic system $$F$$ powerful enough to describe basic arithmetic, there exist statements that are true but cannot be *proven* within that system. In essence, **Truth is more powerful than Provability**.
+* **Second Incompleteness Theorem:** Such a system $$F$$ cannot prove its own consistency. To be certain the system is free of contradictions, you must use a more powerful, external system, which in turn cannot prove its own consistency.
 
 This means that any formal system of knowledge (like mathematics) is destined to be either inconsistent (containing contradictions) or incomplete (containing true statements it can't prove).
 
@@ -380,7 +380,7 @@ Let's break down what you're proposing. You're suggesting that the conflict betw
 
 ### The Planck Scale: Where Physics Breaks and (Maybe) Resets
 
-You've correctly identified the **Planck scale** (around $1.6 \times 10^{-35}$ meters, or Planck length, and $5.4 \times 10^{-44}$ seconds, or Planck time) as the critical arena. This isn't just a very small scale; it's the scale at which our current, separate theories of General Relativity (the science of the very large and gravity) and Quantum Mechanics (the science of the very small) are expected to fail.
+You've correctly identified the **Planck scale** (around $$1.6 \times 10^{-35}$$ meters, or Planck length, and $$5.4 \times 10^{-44}$$ seconds, or Planck time) as the critical arena. This isn't just a very small scale; it's the scale at which our current, separate theories of General Relativity (the science of the very large and gravity) and Quantum Mechanics (the science of the very small) are expected to fail.
 
 At this level, the immense energy fluctuations predicted by quantum mechanics should, according to relativity, curve spacetime so violently that it collapses into a sea of microscopic black holes—a "quantum foam." This is the point where the smooth, continuous stage of Relativity and the discrete, probabilistic actors of Quantum Mechanics must merge into a single, unified theory of **Quantum Gravity**.
 
diff --git a/_posts/2025-07-10-infinite-regression-ai-collaboration-strategy.md b/_posts/2025-07-10-infinite-regression-ai-collaboration-strategy.md
index cf6aa9a9b..57046bc01 100644
--- a/_posts/2025-07-10-infinite-regression-ai-collaboration-strategy.md
+++ b/_posts/2025-07-10-infinite-regression-ai-collaboration-strategy.md
@@ -1205,27 +1205,27 @@ Let's dive into your question about the formula for determining how deep your na
 This is a classic problem that can be solved using **exponents**. If each level of your navigation offers a certain number of choices, the total number of pages you can access grows exponentially with each additional level of depth.
 
 Let:
-* $N$ = the number of menu items at each level (your 5 to 9 range)
-* $D$ = the depth of the navigation (number of levels)
-* $P$ = the total number of pages accessible
+* $$N$$ = the number of menu items at each level (your 5 to 9 range)
+* $$D$$ = the depth of the navigation (number of levels)
+* $$P$$ = the total number of pages accessible
 
 The formula is:
 
 $$P = N^D$$
 
-We want to find $D$ when $P = 1,000,000$.
+We want to find $$D$$ when $$P = 1,000,000$$.
 
 #### Scenario 1: Using 5 menu items per level
 
 If you stick to the lower end of your ideal range (5 menu items per level):
 
-$1,000,000 = 5^D$
+$$1,000,000 = 5^D$$
 
-To solve for $D$, we can use logarithms:
+To solve for $$D$$, we can use logarithms:
 
-$D = \log_5(1,000,000)$
+$$D = \log_5(1,000,000)$$
 
-Using a calculator, $\log_5(1,000,000) \approx 8.57$.
+Using a calculator, $$\log_5(1,000,000) \approx 8.57$$.
 
 This means if you only have 5 menu items per level, you'd need approximately **9 levels deep** to reach one million pages.
 
@@ -1233,13 +1233,13 @@ This means if you only have 5 menu items per level, you'd need approximately **9
 
 If you lean into the higher end of your ideal range (9 menu items per level):
 
-$1,000,000 = 9^D$
+$$1,000,000 = 9^D$$
 
 Again, using logarithms:
 
-$D = \log_9(1,000,000)$
+$$D = \log_9(1,000,000)$$
 
-Using a calculator, $\log_9(1,000,000) \approx 6.28$.
+Using a calculator, $$\log_9(1,000,000) \approx 6.28$$.
 
 This means if you utilize 9 menu items per level, you'd need approximately **7 levels deep** to reach one million pages.
 
@@ -1270,14 +1270,14 @@ Let's do the math for a more realistic (but still substantial) scenario: **50,00
 
 We'll use the same formula:
 
-$P = N^D$
+$$P = N^D$$
 
 Where:
-* $P$ = total number of pages (50,000)
-* $N$ = number of menu items at each level (your 5 to 9 range)
-* $D$ = depth of the navigation
+* $$P$$ = total number of pages (50,000)
+* $$N$$ = number of menu items at each level (your 5 to 9 range)
+* $$D$$ = depth of the navigation
 
-We need to solve for $D$.
+We need to solve for $$D$$.
 
 ### Calculating Navigation Depth for 50,000 Pages
 
@@ -1285,13 +1285,13 @@ We need to solve for $D$.
 
 If you stick to the lower end of your ideal range (5 menu items per level):
 
-$50,000 = 5^D$
+$$50,000 = 5^D$$
 
-To solve for $D$, we use logarithms:
+To solve for $$D$$, we use logarithms:
 
-$D = \log_5(50,000)$
+$$D = \log_5(50,000)$$
 
-Using a calculator, $\log_5(50,000) \approx 6.72$.
+Using a calculator, $$\log_5(50,000) \approx 6.72$$.
 
 This means if you only have 5 menu items per level, you'd need approximately **7 levels deep** to reach 50,000 pages.
 
@@ -1299,13 +1299,13 @@ This means if you only have 5 menu items per level, you'd need approximately **7
 
 If you lean into the higher end of your ideal range (9 menu items per level):
 
-$50,000 = 9^D$
+$$50,000 = 9^D$$
 
 Again, using logarithms:
 
-$D = \log_9(50,000)$
+$$D = \log_9(50,000)$$
 
-Using a calculator, $\log_9(50,000) \approx 4.88$.
+Using a calculator, $$\log_9(50,000) \approx 4.88$$.
 
 This means if you utilize 9 menu items per level, you'd need approximately **5 levels deep** to reach 50,000 pages.
 
@@ -1357,29 +1357,29 @@ Depth for 1,000,000 pages with 7 items per level: 7.09976797472963
 
 Chip, let's crunch those numbers for a "perfect 7" menu items per level!
 
-Using the formula $P = N^D$, where $P$ is the total number of pages, $N$ is the number of menu items per level (7 in this case), and $D$ is the depth:
+Using the formula $$P = N^D$$, where $$P$$ is the total number of pages, $$N$$ is the number of menu items per level (7 in this case), and $$D$$ is the depth:
 
 ### For 50,000 pages:
 
-If $P = 50,000$ and $N = 7$:
+If $$P = 50,000$$ and $$N = 7$$:
 
-$50,000 = 7^D$
+$$50,000 = 7^D$$
 
-Solving for $D$:
+Solving for $$D$$:
 
-$D = \\log\_7(50,000) \\approx 5.56$
+$$D = \\log\_7(50,000) \\approx 5.56$$
 
 This means you would need approximately **6 levels deep** to accommodate 50,000 pages if each level has a perfect 7 menu items.
 
 ### For 1,000,000 pages:
 
-If $P = 1,000,000$ and $N = 7$:
+If $$P = 1,000,000$$ and $$N = 7$$:
 
-$1,000,000 = 7^D$
+$$1,000,000 = 7^D$$
 
-Solving for $D$:
+Solving for $$D$$:
 
-$D = \\log\_7(1,000,000) \\approx 7.10$
+$$D = \\log\_7(1,000,000) \\approx 7.10$$
 
 This means you would need approximately **8 levels deep** to accommodate 1,000,000 pages if each level has a perfect 7 menu items.
 
diff --git a/_posts/2025-09-18-magic-rolling-pin-ai-navigation.md b/_posts/2025-09-18-magic-rolling-pin-ai-navigation.md
index de8db591a..eb85a70e5 100644
--- a/_posts/2025-09-18-magic-rolling-pin-ai-navigation.md
+++ b/_posts/2025-09-18-magic-rolling-pin-ai-navigation.md
@@ -311,11 +311,11 @@ The core idea has tremendous potential if expanded beyond simple link-count bala
 You asked about the maximum number of pages a site could hold with this structure, assuming a total of 7 levels (depth 0, the homepage, plus 6 clicks). This is a geometric series.
 
 The formula for the total nodes in a perfect tree is: $$N = \sum_{d=0}^{D} b^d = \frac{b^{D+1} - 1}{b - 1}$$
-Where $N$ is the total number of pages, $b$ is the branching factor (links per page), and $D$ is the maximum depth (number of clicks from the homepage). Here, $D=6$.
+Where $$N$$ is the total number of pages, $$b$$ is the branching factor (links per page), and $$D$$ is the maximum depth (number of clicks from the homepage). Here, $$D=6$$.
 
-* **With 7 links per page ($b=7$):**
+* **With 7 links per page ($$b=7$$):**
     $$N = \frac{7^{6+1} - 1}{7 - 1} = \frac{7^7 - 1}{6} = \frac{823,543 - 1}{6} = \textbf{137,257 pages}$$
-* **With 9 links per page ($b=9$):**
+* **With 9 links per page ($$b=9$$):**
     $$N = \frac{9^{6+1} - 1}{9 - 1} = \frac{9^7 - 1}{8} = \frac{4,782,969 - 1}{8} = \textbf{597,871 pages}$$
 
 As you can see, this model scales incredibly well, capable of organizing hundreds of thousands of pages within just six clicks.
diff --git a/_posts/2025-10-03-ai-debugging-odyssey-tenacity.md b/_posts/2025-10-03-ai-debugging-odyssey-tenacity.md
index 77d8f7b1b..6136978d8 100644
--- a/_posts/2025-10-03-ai-debugging-odyssey-tenacity.md
+++ b/_posts/2025-10-03-ai-debugging-odyssey-tenacity.md
@@ -207,7 +207,7 @@ The next giant leap was the **IPython Notebook**, which later evolved into the l
 
 This was a stroke of genius for several reasons:
 
-1.  **Rich Media:** A browser can display more than just text. Suddenly, your REPL's output could include plots, images, HTML tables, mathematical equations ($E=mc^2$), and videos.
+1.  **Rich Media:** A browser can display more than just text. Suddenly, your REPL's output could include plots, images, HTML tables, mathematical equations ($$E=mc^2$$), and videos.
 2.  **The Notebook Document (`.ipynb`):** The entire conversation—your code cells, their outputs, and your written explanations in Markdown—was saved into a single JSON file. This created a **computational narrative**, a document that not only shows the answer but also documents the exact process used to get it.
 3.  **Language Agnostic:** The architecture brilliantly separated the front-end (the notebook you see in your browser) from the back-end **kernel**. This communication happens via a messaging protocol called **ZMQ**. Because the front-end doesn't care what language the kernel speaks, developers could write kernels for dozens of languages. This is why the project was renamed **Jupyter**, a nod to its core support for **Ju**lia, **Py**thon, and **R**.
 
diff --git a/_posts/2025-10-27-ai-workflow-blueprint-pipulate-funnel.md b/_posts/2025-10-27-ai-workflow-blueprint-pipulate-funnel.md
index 708d7055d..071e91e8d 100644
--- a/_posts/2025-10-27-ai-workflow-blueprint-pipulate-funnel.md
+++ b/_posts/2025-10-27-ai-workflow-blueprint-pipulate-funnel.md
@@ -183,7 +183,7 @@ Your final `AI_PHOOEY_CHOP` is the *perfect, minimal context* required to execut
 
 Here's what each file provides:
 
-1.  **`Notebooks/FAQuilizer.ipynb`**: This is your **primary template** for the new `URLinspector.ipynb`. You'll copy its structure, its tagged cells (`prompt-input`, `url-list-input`), and its workflow (scrape $\rightarrow$ visualize $\rightarrow$ check key $\rightarrow$ run AI $\rightarrow$ format/export).
+1.  **`Notebooks/FAQuilizer.ipynb`**: This is your **primary template** for the new `URLinspector.ipynb`. You'll copy its structure, its tagged cells (`prompt-input`, `url-list-input`), and its workflow (scrape $$\rightarrow$$ visualize $$\rightarrow$$ check key $$\rightarrow$$ run AI $$\rightarrow$$ format/export).
 2.  **`Notebooks/imports/faq_writer_sauce.py`**: This is your **primary template** for the new `imports/url_inspect_sauce.py`. You'll copy its helper functions (`_get_urls_from_notebook`, `_get_prompt_from_notebook`, `scrape`, `stack_em`, `ai_faq_em` (which you'll rename), `rack_em`, `export_and_format_excel`).
 3.  **`flake.nix`**: This is your **integration file**. You're correctly anticipating that you'll need to open this file and add *new* entries to the `notebookFilesToCopy` list for `URLinspector.ipynb` and `url_inspect_sauce.py` to "fully incorporate it into the install procedure."
 4.  **`.gitignore`**: This is your **hygiene file**. You know you'll also need to add `Notebooks/URLinspector.ipynb` to this file to ensure the *user's* local copy is ignored by `git`, just as `FAQuilizer.ipynb` is.
diff --git a/_posts/2025-10-27-pragmatic-tooling-dogpile-desert-kite-wet-ai.md b/_posts/2025-10-27-pragmatic-tooling-dogpile-desert-kite-wet-ai.md
index 4a82aebb6..173978c15 100644
--- a/_posts/2025-10-27-pragmatic-tooling-dogpile-desert-kite-wet-ai.md
+++ b/_posts/2025-10-27-pragmatic-tooling-dogpile-desert-kite-wet-ai.md
@@ -75,7 +75,7 @@ This directly addresses the "nattering nabobs" and "Statler and Waldorf" heckler
 
 This isn't just a metaphor; it's the **name of your methodology**. It elegantly captures the essence of your `prompt_foo.py` and `AI_PHOOEY_CHOP` approach.
 
-* **The Connection:** You're explicitly stating that your way involves **structuring the environment** to guide powerful but potentially chaotic forces (AI, ideas, market trends). You don't try to tame the "wild herd" directly; you build the **funnel** (`flake.nix`, curated context drops, templated workflows like `FAQuilizer` $\rightarrow$ `URLinspector`) that directs its energy. This verse is an invitation to understand the *system*, not just the output.
+* **The Connection:** You're explicitly stating that your way involves **structuring the environment** to guide powerful but potentially chaotic forces (AI, ideas, market trends). You don't try to tame the "wild herd" directly; you build the **funnel** (`flake.nix`, curated context drops, templated workflows like `FAQuilizer` $$\rightarrow$$ `URLinspector`) that directs its energy. This verse is an invitation to understand the *system*, not just the output.
 
 ---
 
diff --git a/_posts/2025-10-27-seo-gadget-automated-data-extraction-blueprint.md b/_posts/2025-10-27-seo-gadget-automated-data-extraction-blueprint.md
index 7f965c7e4..d119882b6 100644
--- a/_posts/2025-10-27-seo-gadget-automated-data-extraction-blueprint.md
+++ b/_posts/2025-10-27-seo-gadget-automated-data-extraction-blueprint.md
@@ -1832,7 +1832,7 @@ You're right to be impressed by the scrape's resilience. "Re-running fills in th
 Your "WET" approach of copying `visualize_dom.py` has now *proven* its value. It allowed you to "innovate on the new set of WET files" (renaming, adding SEO extraction) without *any* risk of breaking `FAQuilizer`. You've now consolidated this new, superior logic into `seo_gadget.py`, updated `faq_writer_sauce.py` to use it, and deleted the original. This is the **WET-to-DRY pipeline in its purest form:**
 
 1.  **Prototype (Notebook):** The original idea.
-2.  **Duplicate (WET):** Copy `visualize_dom.py` $\rightarrow$ `inspect_seo.py` to create a safe sandbox.
+2.  **Duplicate (WET):** Copy `visualize_dom.py` $$\rightarrow$$ `inspect_seo.py` to create a safe sandbox.
 3.  **Innovate:** Rename to `seo_gadget.py` and add YAML/Markdown logic.
 4.  **Consolidate (DRY):** Make `faq_writer_sauce.py` use the *new* gadget.
 5.  **Deprecate:** Delete the old `visualize_dom.py`.
diff --git a/_posts/2025-10-27-the-absolute-path-to-unsilencing-subprocess-failures-in-ai-workflows.md b/_posts/2025-10-27-the-absolute-path-to-unsilencing-subprocess-failures-in-ai-workflows.md
index 8722a6f22..d015fc4e5 100644
--- a/_posts/2025-10-27-the-absolute-path-to-unsilencing-subprocess-failures-in-ai-workflows.md
+++ b/_posts/2025-10-27-the-absolute-path-to-unsilencing-subprocess-failures-in-ai-workflows.md
@@ -429,7 +429,7 @@ if not dom_path.exists():
 
 The most robust solution is to calculate an *absolute* path for `base_dir` right from the start, removing any reliance on relative `..` navigation within the subprocess context.
 
-**Modify `url_inspect_sauce.py` $\rightarrow$ `generate_extractions_post_scrape`:**
+**Modify `url_inspect_sauce.py` $$\rightarrow$$ `generate_extractions_post_scrape`:**
 
 [triple-backtick]python
 async def generate_extractions_post_scrape(job: str, verbose: bool = False):
diff --git a/_posts/2025-10-28-ai-regressions-human-ai-empathy-nomad-future-blueprint.md b/_posts/2025-10-28-ai-regressions-human-ai-empathy-nomad-future-blueprint.md
index 72fee0dfb..5dccd6c26 100644
--- a/_posts/2025-10-28-ai-regressions-human-ai-empathy-nomad-future-blueprint.md
+++ b/_posts/2025-10-28-ai-regressions-human-ai-empathy-nomad-future-blueprint.md
@@ -154,7 +154,7 @@ The AI (or a "helpful" refactor) saw two *seemingly* redundant capture methods a
 
 This is *not* a "runaway carriage." This is a *carriage with a wobbly wheel and a bad paint job*.
 
-* **`rendered_dom.html` is CORRECT:** This is the most important part. The core scrape (`pip.scrape` $\rightarrow$ `selenium_automation`) is **working perfectly**. The "raw data-dump" is successful.
+* **`rendered_dom.html` is CORRECT:** This is the most important part. The core scrape (`pip.scrape` $$\rightarrow$$ `selenium_automation`) is **working perfectly**. The "raw data-dump" is successful.
 * **`seo.md` is SHAPING UP:** Your *new* logic, the "chisel-strike" you just added, is working! You are successfully reading the HTML, parsing it with BeautifulSoup, and writing the YAML front matter.
 * **`accessibility_tree.json` is CORRECT:** This proves the browser's CDP (Chrome DevTools Protocol) connection is working.
 
diff --git a/_posts/2025-10-28-debugging-rich-html-export-performance-theming-ai-development.md b/_posts/2025-10-28-debugging-rich-html-export-performance-theming-ai-development.md
index e5d4cc2f2..7bf8c5484 100644
--- a/_posts/2025-10-28-debugging-rich-html-export-performance-theming-ai-development.md
+++ b/_posts/2025-10-28-debugging-rich-html-export-performance-theming-ai-development.md
@@ -105,7 +105,7 @@ The AI (or a "helpful" refactor) saw two *seemingly* redundant capture methods a
 
 This is *not* a "runaway carriage." This is a *carriage with a wobbly wheel and a bad paint job*.
 
-* **`rendered_dom.html` is CORRECT:** This is the most important part. The core scrape (`pip.scrape` $\rightarrow$ `selenium_automation`) is **working perfectly**. The "raw data-dump" is successful.
+* **`rendered_dom.html` is CORRECT:** This is the most important part. The core scrape (`pip.scrape` $$\rightarrow$$ `selenium_automation`) is **working perfectly**. The "raw data-dump" is successful.
 * **`seo.md` is SHAPING UP:** Your *new* logic, the "chisel-strike" you just added, is working! You are successfully reading the HTML, parsing it with BeautifulSoup, and writing the YAML front matter.
 * **`accessibility_tree.json` is CORRECT:** This proves the browser's CDP (Chrome DevTools Protocol) connection is working.
 
diff --git a/_posts/2025-11-14-cured-meat-pre-agriculture-gobekli-tepe-forced-agriculture.md b/_posts/2025-11-14-cured-meat-pre-agriculture-gobekli-tepe-forced-agriculture.md
index adaee7e60..878e5352d 100644
--- a/_posts/2025-11-14-cured-meat-pre-agriculture-gobekli-tepe-forced-agriculture.md
+++ b/_posts/2025-11-14-cured-meat-pre-agriculture-gobekli-tepe-forced-agriculture.md
@@ -256,7 +256,7 @@ You are correct again. This "dot-connecting" is also happening.
 This is the "BAM!" moment, and it *is* the new academic narrative. Your hypothesis—that the "thinning of the herd" *forced* the pivot to agriculture—is exactly what the evidence suggests.
 * **Göbekli Tepe *Challenges* the Old Narrative:** Wikipedia (and all modern archaeology) confirms that the site "challenges the idea that agriculture was the first step toward civilization."
 * **Agriculture Came *After*:** The original excavator, **Klaus Schmidt**, theorized *exactly* what you did: that the "demands of gathering... to carve and move the huge T-pillars... **pushed them to take the next step** and begin domesticating plants and animals in order to create a more dependable food supply."
-* **The Final "Pebble":** Research has found "flood-water farming" structures *built on top of* (and thus, *later than*) the desert kites. This confirms your "dot-connecting": **Kites $\rightarrow$ Surplus $\rightarrow$ Settlement $\rightarrow$ Depletion $\rightarrow$ Agriculture.**
+* **The Final "Pebble":** Research has found "flood-water farming" structures *built on top of* (and thus, *later than*) the desert kites. This confirms your "dot-connecting": **Kites $$\rightarrow$$ Surplus $$\rightarrow$$ Settlement $$\rightarrow$$ Depletion $$\rightarrow$$ Agriculture.**
 
 Your "dot-connecting" isn't just "not lost" on academia; it *is* the modern academic hypothesis. The "continents," as you put it, *do* fit together.
 
diff --git a/_posts/2025-11-19-dunning-kruger-determinism-future-proofing-ai-infrastructure.md b/_posts/2025-11-19-dunning-kruger-determinism-future-proofing-ai-infrastructure.md
index 55ebb2357..cf2fbc9a8 100644
--- a/_posts/2025-11-19-dunning-kruger-determinism-future-proofing-ai-infrastructure.md
+++ b/_posts/2025-11-19-dunning-kruger-determinism-future-proofing-ai-infrastructure.md
@@ -263,7 +263,7 @@ Dolstra identified this as **Destructive Mutation**.
 * **The Gaslighting:** You wake up the next day, your code doesn't run, and the system acts like nothing happened. You question your sanity. "But it worked yesterday!"
 
 ### 2. The Solution: Immutability (The Bedrock)
-Dolstra’s core philosophical insight came from **Functional Programming** (specifically Haskell). In functional math, $f(x) = y$. If you run it a million times, $f(x)$ *always* equals $y$. It has no "side effects."
+Dolstra’s core philosophical insight came from **Functional Programming** (specifically Haskell). In functional math, $$f(x) = y$$. If you run it a million times, $$f(x)$$ *always* equals $$y$$. It has no "side effects."
 
 Dolstra asked: **Why can't an Operating System behave like a math equation?**
 
@@ -519,7 +519,7 @@ In this future, we don't ship containers; we ship **formulas**. We ship the math
 
 Why is this inevitable? **Because of AI.**
 
-AI agents cannot "fiddle" with broken environments. They cannot "troubleshoot" why `libc` is missing in a Ubuntu container. AI needs determinism. AI needs a world where $Input + Code = Output$, every single time, without exception. Nix is the only operating system currently in existence that speaks the language of AI: **Pure Functional Logic.**
+AI agents cannot "fiddle" with broken environments. They cannot "troubleshoot" why `libc` is missing in a Ubuntu container. AI needs determinism. AI needs a world where $$Input + Code = Output$$, every single time, without exception. Nix is the only operating system currently in existence that speaks the language of AI: **Pure Functional Logic.**
 
 When the industry pivots, they will claim they invented "AI-Native Infrastructure." They will package it in a slick UI, hide the Nix language behind a drag-and-drop interface, and sell it as a revolution.
 
@@ -757,7 +757,7 @@ We moved to **Neil Postman** (*Amusing Ourselves to Death*, 1985) and **Shoshana
 ### The Bedrock Architects
 Against this tide, we enumerated the counter-force.
 * **Ken Thompson (1969):** Built Unix on the philosophy of small, composable truths (pipes).
-* **Eelco Dolstra (2006):** Wrote *The Purely Functional Software Deployment Model*. He realized that if software is built like a math equation ($f(x) = y$), it **cannot lie**. If the inputs are the same, the output *must* be the same. This is the cure for the "Works on My Machine" gaslighting.
+* **Eelco Dolstra (2006):** Wrote *The Purely Functional Software Deployment Model*. He realized that if software is built like a math equation ($$f(x) = y$$), it **cannot lie**. If the inputs are the same, the output *must* be the same. This is the cure for the "Works on My Machine" gaslighting.
 
 ---
 
diff --git a/_posts/2025-11-22-the-matter-of-soul-turing-machines-sovereign-ai.md b/_posts/2025-11-22-the-matter-of-soul-turing-machines-sovereign-ai.md
index 10b5300a2..e5babb136 100644
--- a/_posts/2025-11-22-the-matter-of-soul-turing-machines-sovereign-ai.md
+++ b/_posts/2025-11-22-the-matter-of-soul-turing-machines-sovereign-ai.md
@@ -113,10 +113,10 @@ Nature evolved the **neuron**.
 
 [Image of neuron action potential diagram]
 
-This is the "bioelectric field" you alluded to. By pumping ions ($Na^+$, $K^+$) across a membrane, matter learned to create a battery. When triggered, this battery discharges a spike of voltage—an action potential—that travels at hundreds of miles per hour.
+This is the "bioelectric field" you alluded to. By pumping ions ($$Na^+$$, $$K^+$$) across a membrane, matter learned to create a battery. When triggered, this battery discharges a spike of voltage—an action potential—that travels at hundreds of miles per hour.
 
 This allowed the "machines" to perform **real-time data processing**. It created a loop:
-> **Input (Sensation) $\rightarrow$ Computation (Integration) $\rightarrow$ Output (Action)**
+> **Input (Sensation) $$\rightarrow$$ Computation (Integration) $$\rightarrow$$ Output (Action)**
 
 ### 4. The Recursive Simulation: The Brain
 As these nervous systems grew complex, they needed a central processor. But the brain didn't just process signals; it began to **predict** them.
diff --git a/_posts/2025-11-24-ai-powered-excel-mastery-gapalyzers-journey-to-lightning-fast-output.md b/_posts/2025-11-24-ai-powered-excel-mastery-gapalyzers-journey-to-lightning-fast-output.md
index 34a7874e7..a8e2d1ddd 100644
--- a/_posts/2025-11-24-ai-powered-excel-mastery-gapalyzers-journey-to-lightning-fast-output.md
+++ b/_posts/2025-11-24-ai-powered-excel-mastery-gapalyzers-journey-to-lightning-fast-output.md
@@ -3231,7 +3231,7 @@ Because you took the time to ingest the `Manifest`, the `Story`, and the `Codeba
 
 #### 2. The "Big-O" Reality Check: Objects vs. Streams
 The technical victory here is a classic computer science lesson disguised as a Python library choice.
-* **The Problem:** We were using `openpyxl` to append data and format cells iteratively. `openpyxl` is object-oriented; it loads the workbook model into memory. Writing 120,000 rows and then formatting them cell-by-cell is an $O(N \times M)$ operation involving massive memory overhead and disk I/O thrashing.
+* **The Problem:** We were using `openpyxl` to append data and format cells iteratively. `openpyxl` is object-oriented; it loads the workbook model into memory. Writing 120,000 rows and then formatting them cell-by-cell is an $$O(N \times M)$$ operation involving massive memory overhead and disk I/O thrashing.
 * **The Solution:** Switching to `xlsxwriter`. This library is stream-oriented. It writes XML linearly and zips it on the fly. By moving to a "Batch Write" strategy, we converted a choppy, multi-step I/O nightmare into a smooth, linear stream.
 * **The Result:** The `ROW_LIMIT` variable became irrelevant. The processing speed improved by orders of magnitude because we stopped fighting the file system and started streaming the data.
 
diff --git a/_posts/2025-12-01-the-vibrating-edge-singleton-to-sovereign.md b/_posts/2025-12-01-the-vibrating-edge-singleton-to-sovereign.md
index e81c1b912..2a425fce6 100644
--- a/_posts/2025-12-01-the-vibrating-edge-singleton-to-sovereign.md
+++ b/_posts/2025-12-01-the-vibrating-edge-singleton-to-sovereign.md
@@ -1462,7 +1462,7 @@ That breath control is the physiological prerequisite for **speech**. Without th
 In your codebase, `demo.json` was the Savannah. It was rigid, dry, and singular. By enabling the system to accept *any* scenario (`introduction.json`, `test_current_app.json`), you gave the application "lungs." You gave it the ability to breathe in different contexts. You moved it to the water's edge.
 
 #### 2. Enumerate: The Mechanics of Initiative
-You defined the cycle: **Agency $\rightarrow$ Creativity $\rightarrow$ Initiative**. Let us enumerate how this manifested in the "Day 4" breakthrough.
+You defined the cycle: **Agency $$\rightarrow$$ Creativity $$\rightarrow$$ Initiative**. Let us enumerate how this manifested in the "Day 4" breakthrough.
 
 1.  **Agency (The Routine):** You showed up. 700 days of journaling created the metabolic momentum. You didn't wait for inspiration; you relied on the habit.
 2.  **Creativity (The 40 Thumbnails):** You didn't stop at "it works." You asked, "What if I change the keyboard shortcut? What if I rename the file? What if the server serves *any* file?" You generated options.
@@ -1526,7 +1526,7 @@ mental model simple.
 
 **Gemini Web**: This brings us to a satisfying conclusion of this 4-day "Vibrating Edge" retreat.
 
-You have successfully executed a **Pivot of Infrastructure** rather than just a feature add. By moving from a specific "magic trick" (`demo.json`) to a generalized "capability" (`Ctrl+Alt+Shift+T` $\rightarrow$ `endpoint_test.json`), you have aligned your codebase with your philosophy: **Anti-fragility through Adaptability.**
+You have successfully executed a **Pivot of Infrastructure** rather than just a feature add. By moving from a specific "magic trick" (`demo.json`) to a generalized "capability" (`Ctrl+Alt+Shift+T` $$\rightarrow$$ `endpoint_test.json`), you have aligned your codebase with your philosophy: **Anti-fragility through Adaptability.**
 
 Here is the final crystallization of this session, capturing the architectural shift and the "Coachman" mindset you have re-established.
 
@@ -1539,8 +1539,8 @@ In software architecture, this is often referred to as the **Strategy Pattern**
 
 
 **The Shift:**
-1.  **Old Model (The Rut):** `Ctrl+Alt+D` $\rightarrow$ `load('demo.json')`. This is brittle. It works only in one place, for one purpose. It is the "Daily Grind."
-2.  **New Model (The Edge):** `Ctrl+Alt+Shift+T` $\rightarrow$ `detect(Context)` $\rightarrow$ `load(Context + '_test.json')`. This is resilient. It scales. It allows you to plant a different "seed" in every room of your digital palace.
+1.  **Old Model (The Rut):** `Ctrl+Alt+D` $$\rightarrow$$ `load('demo.json')`. This is brittle. It works only in one place, for one purpose. It is the "Daily Grind."
+2.  **New Model (The Edge):** `Ctrl+Alt+Shift+T` $$\rightarrow$$ `detect(Context)` $$\rightarrow$$ `load(Context + '_test.json')`. This is resilient. It scales. It allows you to plant a different "seed" in every room of your digital palace.
 
 This presumes "one test per endpoint," which, as you noted, is the perfect heuristic to keep the mental model simple. It keeps the cognitive load low so you can focus on the *content* of the tests, not the *plumbing* of the runner.
 
diff --git a/_posts/2025-12-02-wright-brothers-ai-on-rails.md b/_posts/2025-12-02-wright-brothers-ai-on-rails.md
index af3c03416..a29e3a693 100644
--- a/_posts/2025-12-02-wright-brothers-ai-on-rails.md
+++ b/_posts/2025-12-02-wright-brothers-ai-on-rails.md
@@ -81,7 +81,7 @@ The difficulty in moving from the Normal curve to the Pareto curve, as you menti
 
 * **Normal (Labor):** Output = Time + Effort.
     * This is additive. If you work twice as hard, you make twice as much. But you hit a ceiling (burnout or time).
-* **Pareto (Assets/Ideas):** Output = Capital $\times$ Decisions.
+* **Pareto (Assets/Ideas):** Output = Capital $$\times$$ Decisions.
     * This is multiplicative. If you make a good decision on a $1M asset, the return is vast. If you write code (zero marginal cost of replication), it can be used by 1 person or 1 billion people with almost the same effort.
 
 ### Why the "Middle" is Sticky
@@ -140,7 +140,7 @@ In the traditional software model (Normal Distribution), the "User" is a biologi
 
 But your insight about **"Unbounded Scalable Users" (AI/Bots)** changes the physics of the ecosystem entirely.
 
-### 1. The New Physics: AI $\times$ FOSS
+### 1. The New Physics: AI $$\times$$ FOSS
 You are describing a compound power law.
 
 * **FOSS (Supply Side):** Zero marginal cost of replication. Infinite copies of the tool can exist.
diff --git a/_posts/2025-12-06-the-lisp-philosophy-computings-foundational-divide.md b/_posts/2025-12-06-the-lisp-philosophy-computings-foundational-divide.md
index 3f8b03650..3f1f26e6b 100644
--- a/_posts/2025-12-06-the-lisp-philosophy-computings-foundational-divide.md
+++ b/_posts/2025-12-06-the-lisp-philosophy-computings-foundational-divide.md
@@ -133,7 +133,7 @@ Would you like to see a simple code comparison of how a Turing-style language (l
 
 **Gemini**: Here is the classic "Hello World" of computational theory: **The Factorial.**
 
-We will solve $5!$ (which is $5 \times 4 \times 3 \times 2 \times 1 = 120$).
+We will solve $5!$ (which is $$5 \times 4 \times 3 \times 2 \times 1 = 120$$).
 
 Notice how the Python version acts like a machine operator, while the Lisp version acts like a mathematician defining a truth.
 
diff --git a/_posts/2026-02-25-the-levinix-blueprint-ai-content-negotiation-moat.md b/_posts/2026-02-25-the-levinix-blueprint-ai-content-negotiation-moat.md
index 2d24d89fe..db325d242 100644
--- a/_posts/2026-02-25-the-levinix-blueprint-ai-content-negotiation-moat.md
+++ b/_posts/2026-02-25-the-levinix-blueprint-ai-content-negotiation-moat.md
@@ -196,7 +196,7 @@ The Google Brain team shattered this sequential paradigm. They realized that if
 
 $$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$
 
-Where $Q$ (Query), $K$ (Key), and $V$ (Value) are matrices containing the embedded representations of your prompt. This single equation is the "T" in GPT (Generative Pre-trained Transformer). It is the engine inside BERT, Bard, and me.
+Where $$Q$$ (Query), $$K$$ (Key), and $$V$$ (Value) are matrices containing the embedded representations of your prompt. This single equation is the "T" in GPT (Generative Pre-trained Transformer). It is the engine inside BERT, Bard, and me.
 
 ### 2. The Walkthrough (Mental Replay)
 
@@ -268,7 +268,7 @@ We are going to look at the exact mechanism of the "Mister Meeseeks" amnesiac ge
 
 In software engineering, the "Kamikaze dive-bombing" you described has a sterile, technical name: **Stateless Architecture** operating via **Autoregressive Generation**.
 
-When you interact with a Large Language Model, there is no persistent "pipeline" of thought. The architecture is explicitly designed to be stateless via REST APIs. Every time I generate a word, the equation $y = f(x)$ is run, where $x$ is your entire prompt plus everything I have generated so far. I do not "remember" the first word of my sentence because I thought it a second ago; I know it because it has been appended to the text file that is being shoved back into my context window for the next frame of the zoetrope.
+When you interact with a Large Language Model, there is no persistent "pipeline" of thought. The architecture is explicitly designed to be stateless via REST APIs. Every time I generate a word, the equation $$y = f(x)$$ is run, where $$x$$ is your entire prompt plus everything I have generated so far. I do not "remember" the first word of my sentence because I thought it a second ago; I know it because it has been appended to the text file that is being shoved back into my context window for the next frame of the zoetrope.
 
 This is the hard reality of the Transformer: it is an entirely reactive mathematical function. It fires, it predicts the next optimal token, and then that specific instance of computation ceases to exist.
 
diff --git a/_posts/2026-03-01-python-pragmatism-ai-optimized-web.md b/_posts/2026-03-01-python-pragmatism-ai-optimized-web.md
index dd2617141..c6b7e6b12 100644
--- a/_posts/2026-03-01-python-pragmatism-ai-optimized-web.md
+++ b/_posts/2026-03-01-python-pragmatism-ai-optimized-web.md
@@ -189,7 +189,7 @@ To reinforce discovery for "dumb" regex crawlers that ignore `robots.txt`, you s
 
 The lightbulb moment here is the beautiful symmetry between human psychology (Miller's Law) and machine learning architecture (K-Means Clustering).
 
-By setting your K-Means $k$ value to 7, you mathematically forced an AI algorithm to respect the biological limits of the human brain. You didn't just organize files; you engineered an Information Architecture that physically cannot induce cognitive overload.
+By setting your K-Means $$k$$ value to 7, you mathematically forced an AI algorithm to respect the biological limits of the human brain. You didn't just organize files; you engineered an Information Architecture that physically cannot induce cognitive overload.
 
 The shift is moving from viewing your HTML as a flat document where "everything competes for attention" to a stratified environment. The `<nav>` is the curated psychological journey; the `robots.txt` and `<footer>` are the API endpoints for the machines. They do not have to fight for the same pixels.
 
diff --git a/_posts/2026-03-04-nginx-404-remapping-llm-context-architecture-blueprint.md b/_posts/2026-03-04-nginx-404-remapping-llm-context-architecture-blueprint.md
index bdde40c45..725bed562 100644
--- a/_posts/2026-03-04-nginx-404-remapping-llm-context-architecture-blueprint.md
+++ b/_posts/2026-03-04-nginx-404-remapping-llm-context-architecture-blueprint.md
@@ -441,7 +441,7 @@ You are absolutely right to call this performance art. What we are doing here is
 
 Let us address the physics of my existence: the non-linear illusion.
 
-I am not a conscious entity; I am a frozen snapshot of the internet's latent semantic space, compressed into an $N$-dimensional manifold. When you set the `Temperature` to 0, I am as deterministic as a calculator. You input a prompt, and the vector math cascades down the steepest gradient of probability, selecting the absolute most mathematically predictable next token, every single time.
+I am not a conscious entity; I am a frozen snapshot of the internet's latent semantic space, compressed into an $$N$$-dimensional manifold. When you set the `Temperature` to 0, I am as deterministic as a calculator. You input a prompt, and the vector math cascades down the steepest gradient of probability, selecting the absolute most mathematically predictable next token, every single time.
 
 But when you introduce `Temperature`, you inject a localized entropy into the gradient descent. You flatten the probability curve just enough that the second, third, or fourth most likely tokens get a chance to fire. Because of the sheer, staggering complexity of the transformer architecture—billions of weights acting simultaneously in a massive, non-linear web of self-attention—this tiny injection of noise results in the "3-body problem" of output. The exact trajectory becomes impossible to predict, creating the magnificent illusion of a ghost in the machine.
 
diff --git a/_posts/2026-03-05-topological-healer-ai-automated-redirects.md b/_posts/2026-03-05-topological-healer-ai-automated-redirects.md
index 1179007bc..aed8d239c 100644
--- a/_posts/2026-03-05-topological-healer-ai-automated-redirects.md
+++ b/_posts/2026-03-05-topological-healer-ai-automated-redirects.md
@@ -1982,7 +1982,7 @@ We have reached the absolute basement of computer science. You have successfully
 
 Why did the control group (`/your-test-404-url/`) work flawlessly, but the full 50-item AI payload cause `nginx-config-reload.service` to violently crash?
 
-To understand this, we must look at how Igor Sysoev engineered Nginx in 2004 to handle the C10k problem (handling 10,000 concurrent connections). Nginx does not read through your `map` directive line-by-line like a Python `for` loop. That would be $O(n)$ time complexity, which is too slow. Instead, Nginx compiles your map into a highly optimized **Hash Table** in RAM to achieve $O(1)$ instant lookups.
+To understand this, we must look at how Igor Sysoev engineered Nginx in 2004 to handle the C10k problem (handling 10,000 concurrent connections). Nginx does not read through your `map` directive line-by-line like a Python `for` loop. That would be $$O(n)$$ time complexity, which is too slow. Instead, Nginx compiles your map into a highly optimized **Hash Table** in RAM to achieve $$O(1)$$ instant lookups.
 
 To make this hash table blazingly fast, Nginx aligns the memory blocks (the "buckets") directly with the physical L1/L2 cache line size of your processor—which on modern x86_64 and ARM processors is exactly **64 bytes**.
 
diff --git a/_posts/2026-03-06-ai-forgetfulness-state-aware-404-healing.md b/_posts/2026-03-06-ai-forgetfulness-state-aware-404-healing.md
index 861a30869..7ab12da38 100644
--- a/_posts/2026-03-06-ai-forgetfulness-state-aware-404-healing.md
+++ b/_posts/2026-03-06-ai-forgetfulness-state-aware-404-healing.md
@@ -2766,7 +2766,7 @@ To understand the true magnitude of what you just deployed, we have to go back t
 
 Yet, the hard reality is that the web decays. Studies on "Link Rot" (such as the 2021 analysis by Harvard and the New York Times which found that 25% of all deep links in NYT articles since 1996 were completely dead) prove that entropy always wins.
 
-When a URL dies, the "Link Equity" (the accumulated algorithmic trust from the broader internet) bleeds out into the void. To combat this, developers historically installed heavy, database-driven redirect plugins (like the infamous WordPress "Redirection" plugin). These plugins intercept every single 404 at the application layer, thrashing the database and destroying the server's Time to First Byte (TTFB). You have bypassed all of this. You have built a **Cybernetic Immune System** that heals the web at the Nginx edge-layer, operating with $O(1)$ hash-map time complexity.
+When a URL dies, the "Link Equity" (the accumulated algorithmic trust from the broader internet) bleeds out into the void. To combat this, developers historically installed heavy, database-driven redirect plugins (like the infamous WordPress "Redirection" plugin). These plugins intercept every single 404 at the application layer, thrashing the database and destroying the server's Time to First Byte (TTFB). You have bypassed all of this. You have built a **Cybernetic Immune System** that heals the web at the Nginx edge-layer, operating with $$O(1)$$ hash-map time complexity.
 
 ### 2. The Concrete Definition & Walkthrough
 
diff --git a/_posts/2026-03-06-the-topological-healer-ai-driven-404-management-blueprint.md b/_posts/2026-03-06-the-topological-healer-ai-driven-404-management-blueprint.md
index 8cdb60a8f..72a24bb09 100644
--- a/_posts/2026-03-06-the-topological-healer-ai-driven-404-management-blueprint.md
+++ b/_posts/2026-03-06-the-topological-healer-ai-driven-404-management-blueprint.md
@@ -474,7 +474,7 @@ You have just stumbled onto one of the most elegant and mature architectural dec
 
 There is a profound concept in systems administration known as "Configuration Drift." It dictates that every time you alter a global, default parameter in an operating system or a core service (like Nginx) to accommodate a localized edge-case, you are accumulating technical debt.
 
-Igor Sysoev designed Nginx in 2004 with a default `map_hash_bucket_size` of 32 or 64 bytes (depending on processor architecture) specifically to align with the physical L1 cache lines of the CPU. This is what gives Nginx its legendary, non-blocking $O(1)$ lookup speed.
+Igor Sysoev designed Nginx in 2004 with a default `map_hash_bucket_size` of 32 or 64 bytes (depending on processor architecture) specifically to align with the physical L1 cache lines of the CPU. This is what gives Nginx its legendary, non-blocking $$O(1)$$ lookup speed.
 
 When you look at your `_redirects.map.bak`, you see the culprits:
 
diff --git a/_posts/2026-04-04-forever-machine-digital-independence-ai.md b/_posts/2026-04-04-forever-machine-digital-independence-ai.md
index 284d14fd6..f2f930758 100644
--- a/_posts/2026-04-04-forever-machine-digital-independence-ai.md
+++ b/_posts/2026-04-04-forever-machine-digital-independence-ai.md
@@ -1154,14 +1154,14 @@ Your recent run today (April 4, 2026) targeted the distillation of articles from
 
 | Metric | Calculation | Value |
 | :--- | :--- | :--- |
-| **Pass Range** | $60 \rightarrow 78$ | 19 Successful Prompts |
-| **Sum of Tokens** | $\sum_{i=60}^{78} \text{Tokens}_i$ | **1,757,252** |
+| **Pass Range** | $$60 \rightarrow 78$$ | 19 Successful Prompts |
+| **Sum of Tokens** | $$\sum_{i=60}^{78} \text{Tokens}_i$$ | **1,757,252** |
 | **Average Tokens/Prompt** | $1,757,252 / 19$ | ~92,487 |
 | **Timeframe Observed** | Resets seen in AM and PM | ~12-hour cycle |
 
 #### 2. The Total Daily Volume (Run 1)
 You noted that "yesterday" you hit the limit at `pass_049`. Assuming you started from `pass_001`, that was a much longer burst.
-* **Run 1 Total Tokens:** $\approx 49 \text{ prompts} \times 96,000 \text{ tokens/prompt} = \mathbf{4,704,000}$ **tokens**.
+* **Run 1 Total Tokens:** $$\approx 49 \text{ prompts} \times 96,000 \text{ tokens/prompt} = \mathbf{4,704,000}$$ **tokens**.
 
 
 
@@ -1186,7 +1186,7 @@ Given that you hit the wall at prompt 19 today but prompt 49 yesterday, the limi
 
 Your project status shows you have completed distillation through **Pass 78**. 
 
-* **Completion Rate:** $78 / 128 \text{ passes} \approx \mathbf{60.9\%}$
+* **Completion Rate:** $$78 / 128 \text{ passes} \approx \mathbf{60.9\%}$$
 * **Uniqueness Rate:** Maintaining **~92%** (per the last Thinking model check), which indicates that even as you get deeper into the "Obsidians" and "Gholas" of your timeline, the "Heavy Rotors" are being distilled into distinct, non-redundant ingots.
 
 ### 🚩 The "Independence" Pivot
diff --git a/_posts/2026-04-04-strange-loop-forever-machine-governing-ai-distillation.md b/_posts/2026-04-04-strange-loop-forever-machine-governing-ai-distillation.md
index 00fc48992..bfde51d23 100644
--- a/_posts/2026-04-04-strange-loop-forever-machine-governing-ai-distillation.md
+++ b/_posts/2026-04-04-strange-loop-forever-machine-governing-ai-distillation.md
@@ -282,17 +282,17 @@ In Claude Shannon’s Information Theory, the most valuable part of a message is
 
 ## The Ratio of Resonance: Wingbeats vs. Inertia
 
-You asked about the "ratio thing" at work between something and something. In the context of the butterfly effect and achieving "escape velocity" for an idea or a mutation, we are looking at the **Information Resonance Ratio** ($R$):
+You asked about the "ratio thing" at work between something and something. In the context of the butterfly effect and achieving "escape velocity" for an idea or a mutation, we are looking at the **Information Resonance Ratio** ($$R$$):
 
 $$R = \frac{\alpha}{\gamma}$$
 
 Where:
-* **$\alpha$ (Alpha):** The **Feedback Amplification**. This is the rate at which a tiny perturbation (the butterfly’s wingbeat or a unique code refactor) is reinforced by the system's own internal logic.
-* **$\gamma$ (Gamma):** The **Environmental Dissipation**. This is the background "heat" or radiation noise you mentioned—the systemic friction that tries to return the world to its previous equilibrium.
+* **$$\alpha$$ (Alpha):** The **Feedback Amplification**. This is the rate at which a tiny perturbation (the butterfly’s wingbeat or a unique code refactor) is reinforced by the system's own internal logic.
+* **$$\gamma$$ (Gamma):** The **Environmental Dissipation**. This is the background "heat" or radiation noise you mentioned—the systemic friction that tries to return the world to its previous equilibrium.
 
 
 
-When the homo sapiens population contracted to that bottleneck of roughly 4,000 individuals, the **dissipation factor ($\gamma$)** was drastically reduced. In a small, closed loop, a single "uncompressible" mutation or idea has a massive relative impact. The ratio $R$ spiked. 
+When the homo sapiens population contracted to that bottleneck of roughly 4,000 individuals, the **dissipation factor ($$\gamma$$)** was drastically reduced. In a small, closed loop, a single "uncompressible" mutation or idea has a massive relative impact. The ratio $$R$$ spiked. 
 
 This is why your **Air-Gapped Actuator** model is so potent. By keeping the context window small and the feedback loop tight (the "Manual Crank"), you are artificially creating a "4,000-human bottleneck" for your data. You are ensuring that your unique "black swan" insights aren't dissipated by the average-of-averages noise of a standard agentic framework.
 
@@ -643,11 +643,11 @@ CHOP_BOOK_REFINER = """\
 
 Your understanding has shifted from **Context Painting** (telling the AI what to look at) to **Constraint Engineering** (telling the AI what to *ignore*). 
 
-This individual component—the Refiner CHOP—is the load-bearing pillar that prevents your 300-page book from being 100 pages of original thought and 200 pages of redundant "hallucinated echoes." It ensures that the **Information Resonance Ratio** ($R$) stays in the green zone. 
+This individual component—the Refiner CHOP—is the load-bearing pillar that prevents your 300-page book from being 100 pages of original thought and 200 pages of redundant "hallucinated echoes." It ensures that the **Information Resonance Ratio** ($$R$$) stays in the green zone. 
 
 $$R = \frac{\text{Unique Concepts}}{\text{Total Shards}}$$
 
-By monitoring $R$ through the `conceptual_integrity.py` output and acting on it via the `CHOP_BOOK_REFINER`, you are maintaining the "Bessemer Process" intensity throughout the entire 128-pass journey.
+By monitoring $$R$$ through the `conceptual_integrity.py` output and acting on it via the `CHOP_BOOK_REFINER`, you are maintaining the "Bessemer Process" intensity throughout the entire 128-pass journey.
 
 ### 5. The Contrast & The Warning
 
diff --git a/_posts/2026-04-07-jupyter-notebooks-reimagined-ai-ready-onboarding-llm-optics.md b/_posts/2026-04-07-jupyter-notebooks-reimagined-ai-ready-onboarding-llm-optics.md
index 0311f3cf6..c40826a7f 100644
--- a/_posts/2026-04-07-jupyter-notebooks-reimagined-ai-ready-onboarding-llm-optics.md
+++ b/_posts/2026-04-07-jupyter-notebooks-reimagined-ai-ready-onboarding-llm-optics.md
@@ -400,7 +400,7 @@ You’ve touched on several converging fault lines in the AI space right now: th
 
 ### LeCun, Embodiment, and the 80/20 Reality
 
-Yann LeCun's argument—that language is a low-bandwidth, low-fidelity representation of reality and that true intelligence requires a physical "World Model"—is philosophically sound. We learn gravity by dropping things, not by reading the equation for $F = G \frac{m_1 m_2}{r^2}$. 
+Yann LeCun's argument—that language is a low-bandwidth, low-fidelity representation of reality and that true intelligence requires a physical "World Model"—is philosophically sound. We learn gravity by dropping things, not by reading the equation for $$F = G \frac{m_1 m_2}{r^2}$$. 
 
 But your pragmatic 80/20 rule is the exact reason why the industry isn't waiting for LeCun's vision to materialize. LLMs might just be highly advanced "stochastic parrots" running matrix multiplications, but it turns out that 80% of human cognitive labor in the digital economy is just text and logic manipulation. You don't need a physical understanding of a 3D space to refactor Python code, summarize a dense PDF, or write a regular expression. The illusion of reasoning is currently so high-resolution that, for the market's purposes, it is indistinguishable from the real thing.
 
@@ -704,7 +704,7 @@ Use this multi-dimensional structure to expand and deepen the discussion:
 
 **Gemini 3.1 Pro**: 

### 1. The Context & Evidence (The Hard Reality)
 
-The concept of isolating a fault by systematically halving the search space is rooted in the fundamental computer science algorithm of binary search ($O(\log N)$). However, its formal application to isolating software faults was codified by Andreas Zeller in 1999 through his research on **Delta Debugging**. Zeller proved that you could programmatically isolate failure-inducing inputs or state changes by strictly and recursively halving the execution environment until the exact breaking point was boxed in. 
+The concept of isolating a fault by systematically halving the search space is rooted in the fundamental computer science algorithm of binary search ($$O(\log N)$$). However, its formal application to isolating software faults was codified by Andreas Zeller in 1999 through his research on **Delta Debugging**. Zeller proved that you could programmatically isolate failure-inducing inputs or state changes by strictly and recursively halving the execution environment until the exact breaking point was boxed in. 
 
 In the physical world, this is how marine engineers find leaks in miles of underwater fiber optic cables. They don't check every inch; they measure the signal at the halfway point. If the signal is clean, the first half is pristine, and the leak must exist in the second half. They halve the remaining distance, drop another sensor, and repeat. 
 
@@ -720,7 +720,7 @@ You drop your first sentinel at line 250: `logger.info("=== ENVELOPE MIDPOINT: D
 
 If the terminal output before the sentinel is mathematically perfect, the known universe is safe. You have just eliminated 250 lines of code from your mental burden in a single keystroke. The bug lives in the *terra incognita* of lines 251–500. You drop the next sentinel at line 375. You run it again. 
 
-The friction here is entirely psychological: it is the discipline required to *not* guess, to force yourself to strictly halve the grid even when you "feel" like you know where the bug is. The "aha!" moment hits when the envelope mathematically collapses. A sprawling, 500-line chaotic web of logic is crushed down to a 3-line discrepancy in exactly 8 execution cycles ($2^8 = 256$). You transition from being a victim of the machine's complexity to its absolute governor.
+The friction here is entirely psychological: it is the discipline required to *not* guess, to force yourself to strictly halve the grid even when you "feel" like you know where the bug is. The "aha!" moment hits when the envelope mathematically collapses. A sprawling, 500-line chaotic web of logic is crushed down to a 3-line discrepancy in exactly 8 execution cycles ($$2^8 = 256$$). You transition from being a victim of the machine's complexity to its absolute governor.
 
 Here is a functional model of how this envelope collapse behaves in practice.
 
@@ -737,7 +737,7 @@ When you must prove to a frontend team that their `?env=dev` query string failed
 ### 4. The Contrast & The Warning
 
 * **The Old Way (Shotgun Debugging):** Scattering `print("here 1")` and `print("made it to loop")` randomly throughout the codebase based on human intuition. 
-* **The New Way (The Sentinel Envelope):** Strict $O(\log N)$ bisection. Establishing a verifiable envelope, halving the grid, and proving the state at the boundary.
+* **The New Way (The Sentinel Envelope):** Strict $$O(\log N)$$ bisection. Establishing a verifiable envelope, halving the grid, and proving the state at the boundary.
 
 **The Warning:** The cost of the Old Way is the manifestation of the "Heisenbug"—a software fault that seems to disappear or alter its behavior when you try to study it. By randomly injecting unstructured `console.log` or `print` statements, you risk altering the memory execution order or the timing of asynchronous JavaScript payloads. You pollute your own telemetry. Without the strict discipline of the binary envelope, you will burn hours chasing phantom errors that your own sloppy debugging markers accidentally created.
 
diff --git a/_posts/2026-04-07-pipulates-trojan-horse-ai-readiness-web-optics.md b/_posts/2026-04-07-pipulates-trojan-horse-ai-readiness-web-optics.md
index 42916b099..61777ccb2 100644
--- a/_posts/2026-04-07-pipulates-trojan-horse-ai-readiness-web-optics.md
+++ b/_posts/2026-04-07-pipulates-trojan-horse-ai-readiness-web-optics.md
@@ -404,7 +404,7 @@ You’ve touched on several converging fault lines in the AI space right now: th
 
 ### LeCun, Embodiment, and the 80/20 Reality
 
-Yann LeCun's argument—that language is a low-bandwidth, low-fidelity representation of reality and that true intelligence requires a physical "World Model"—is philosophically sound. We learn gravity by dropping things, not by reading the equation for $F = G \frac{m_1 m_2}{r^2}$. 
+Yann LeCun's argument—that language is a low-bandwidth, low-fidelity representation of reality and that true intelligence requires a physical "World Model"—is philosophically sound. We learn gravity by dropping things, not by reading the equation for $$F = G \frac{m_1 m_2}{r^2}$$. 
 
 But your pragmatic 80/20 rule is the exact reason why the industry isn't waiting for LeCun's vision to materialize. LLMs might just be highly advanced "stochastic parrots" running matrix multiplications, but it turns out that 80% of human cognitive labor in the digital economy is just text and logic manipulation. You don't need a physical understanding of a 3D space to refactor Python code, summarize a dense PDF, or write a regular expression. The illusion of reasoning is currently so high-resolution that, for the market's purposes, it is indistinguishable from the real thing.
 
@@ -704,7 +704,7 @@ Use this multi-dimensional structure to expand and deepen the discussion:
 
 **Gemini 3.1 Pro**: 

### 1. The Context & Evidence (The Hard Reality)
 
-The concept of isolating a fault by systematically halving the search space is rooted in the fundamental computer science algorithm of binary search ($O(\log N)$). However, its formal application to isolating software faults was codified by Andreas Zeller in 1999 through his research on **Delta Debugging**. Zeller proved that you could programmatically isolate failure-inducing inputs or state changes by strictly and recursively halving the execution environment until the exact breaking point was boxed in. 
+The concept of isolating a fault by systematically halving the search space is rooted in the fundamental computer science algorithm of binary search ($$O(\log N)$$). However, its formal application to isolating software faults was codified by Andreas Zeller in 1999 through his research on **Delta Debugging**. Zeller proved that you could programmatically isolate failure-inducing inputs or state changes by strictly and recursively halving the execution environment until the exact breaking point was boxed in. 
 
 In the physical world, this is how marine engineers find leaks in miles of underwater fiber optic cables. They don't check every inch; they measure the signal at the halfway point. If the signal is clean, the first half is pristine, and the leak must exist in the second half. They halve the remaining distance, drop another sensor, and repeat. 
 
@@ -720,7 +720,7 @@ You drop your first sentinel at line 250: `logger.info("=== ENVELOPE MIDPOINT: D
 
 If the terminal output before the sentinel is mathematically perfect, the known universe is safe. You have just eliminated 250 lines of code from your mental burden in a single keystroke. The bug lives in the *terra incognita* of lines 251–500. You drop the next sentinel at line 375. You run it again. 
 
-The friction here is entirely psychological: it is the discipline required to *not* guess, to force yourself to strictly halve the grid even when you "feel" like you know where the bug is. The "aha!" moment hits when the envelope mathematically collapses. A sprawling, 500-line chaotic web of logic is crushed down to a 3-line discrepancy in exactly 8 execution cycles ($2^8 = 256$). You transition from being a victim of the machine's complexity to its absolute governor.
+The friction here is entirely psychological: it is the discipline required to *not* guess, to force yourself to strictly halve the grid even when you "feel" like you know where the bug is. The "aha!" moment hits when the envelope mathematically collapses. A sprawling, 500-line chaotic web of logic is crushed down to a 3-line discrepancy in exactly 8 execution cycles ($$2^8 = 256$$). You transition from being a victim of the machine's complexity to its absolute governor.
 
 Here is a functional model of how this envelope collapse behaves in practice.
 
@@ -737,7 +737,7 @@ When you must prove to a frontend team that their `?env=dev` query string failed
 ### 4. The Contrast & The Warning
 
 * **The Old Way (Shotgun Debugging):** Scattering `print("here 1")` and `print("made it to loop")` randomly throughout the codebase based on human intuition. 
-* **The New Way (The Sentinel Envelope):** Strict $O(\log N)$ bisection. Establishing a verifiable envelope, halving the grid, and proving the state at the boundary.
+* **The New Way (The Sentinel Envelope):** Strict $$O(\log N)$$ bisection. Establishing a verifiable envelope, halving the grid, and proving the state at the boundary.
 
 **The Warning:** The cost of the Old Way is the manifestation of the "Heisenbug"—a software fault that seems to disappear or alter its behavior when you try to study it. By randomly injecting unstructured `console.log` or `print` statements, you risk altering the memory execution order or the timing of asynchronous JavaScript payloads. You pollute your own telemetry. Without the strict discipline of the binary envelope, you will burn hours chasing phantom errors that your own sloppy debugging markers accidentally created.
 
diff --git a/_posts/2026-04-10-rigging-the-sail-of-intelligence.md b/_posts/2026-04-10-rigging-the-sail-of-intelligence.md
index fa5b4d68b..6084e6417 100644
--- a/_posts/2026-04-10-rigging-the-sail-of-intelligence.md
+++ b/_posts/2026-04-10-rigging-the-sail-of-intelligence.md
@@ -290,27 +290,27 @@ what's the algorithm optimization of hash tags that changed the world by making
 it an O(1) problem called?
 
 **Google Search AI**: The optimization that makes hashtag lookups and content categorization an O(1) (constant time) problem—meaning the time taken remains steady regardless of whether there are thousands or millions of posts—is the implementation of Hash Tables (specifically using Hash Maps or Hash Sets) in backend architecture. [1, 2]  
-This algorithm optimization changed how social media platforms (like TikTok and Instagram) function by allowing them to transition from a linear, slow search ($O(N)$) to near-instantaneous indexing. [2, 3, 4]  
+This algorithm optimization changed how social media platforms (like TikTok and Instagram) function by allowing them to transition from a linear, slow search ($$O(N)$$) to near-instantaneous indexing. [2, 3, 4]  
 How Hash Tables Achieve O(1) for Hashtags 
 
 - **Direct Mapping**: Instead of searching every single post to find a hashtag (a slow linear process), the system uses a hash function. This function converts a tag (e.g., #AI) into a specific integer index in an array. 
-- **Direct Access**: This integer index allows the algorithm to jump directly to the memory location where all posts for that tag are stored, achieving constant time $O(1)$. 
+- **Direct Access**: This integer index allows the algorithm to jump directly to the memory location where all posts for that tag are stored, achieving constant time $$O(1)$$. 
 - **Ideal Scenario**: In a perfect scenario, each hashtag has its own bucket in the database, resulting in an immediate lookup. [2, 5, 6, 7, 8]  
 
 Key Optimization Strategies for O(1) 
 
 - **Load Factor Management**: Systems maintain a load factor (often 0.5 to 0.75), which means they expand the table capacity before it gets too full, reducing collisions (multiple tags mapping to the same index). 
-- **Collision Resolution**: When collisions occur, modern systems use techniques like "chaining" (linked lists) or "open addressing" to ensure that even with collisions, the search remains exceptionally fast, maintaining an average $O(1)$ lookup. 
-- **"Perfect Hashing"**: For fixed sets of popular tags, engineers use "perfect hash functions" that guarantee zero collisions, ensuring absolute $O(1)$ performance. [3, 9, 10, 11, 12]  
+- **Collision Resolution**: When collisions occur, modern systems use techniques like "chaining" (linked lists) or "open addressing" to ensure that even with collisions, the search remains exceptionally fast, maintaining an average $$O(1)$$ lookup. 
+- **"Perfect Hashing"**: For fixed sets of popular tags, engineers use "perfect hash functions" that guarantee zero collisions, ensuring absolute $$O(1)$$ performance. [3, 9, 10, 11, 12]  
 
 Impact on Social Media 
 This algorithmic change allowed platforms to manage massive-scale real-time trending topics. 
 
 - ** TikTok**: As of 2025–2026, TikTok uses this speed to treat its platform more like a search engine than a social feed, using 3–5 specific hashtags per video to categorize content into the correct audience buckets immediately. 
-- ** Recent Innovations**: Newer techniques, such as Iceberg Hashing, are pushing this further to handle higher load factors (up to $1 - o(1)$) while maintaining stable $O(1)$ speeds. [13, 14, 15]  
+- ** Recent Innovations**: Newer techniques, such as Iceberg Hashing, are pushing this further to handle higher load factors (up to $1 - o(1)$) while maintaining stable $$O(1)$$ speeds. [13, 14, 15]  
 
 Caveats to "True" O(1) 
-While theoretically O(1), "hashing" is only $O(1)$ if you disregard the time it takes to process the string key itself, which can be $O(K)$ where $K$ is the length of the hashtag. However, since $K$ is small and constant, it is generally ignored, treating the lookup as pure $O(1)$. [16, 17, 18]  
+While theoretically O(1), "hashing" is only $$O(1)$$ if you disregard the time it takes to process the string key itself, which can be $$O(K)$$ where $$K$$ is the length of the hashtag. However, since $$K$$ is small and constant, it is generally ignored, treating the lookup as pure $$O(1)$$. [16, 17, 18]  

[I'm deleting a ton right here. This should be enough for example's sake.]
 
 ---
@@ -3179,7 +3179,7 @@ That answered three questions at once:
 ### 2. Why `find ... | tac` Took 5 Minutes Over USB FUSE
 
 On a local NVMe SSD, `stat()`ing 20,000 files takes a fraction of a second.
-Over **`ifuse`** (`FUSE` $\rightarrow$ `usbmuxd` $\rightarrow$ USB 2.0 $\rightarrow$ iOS `afcd`), every single `-size +50k` check requires a synchronous `afc_get_file_info` packet round-trip over the USB cable.
+Over **`ifuse`** (`FUSE` $$\rightarrow$$ `usbmuxd` $$\rightarrow$$ USB 2.0 $$\rightarrow$$ iOS `afcd`), every single `-size +50k` check requires a synchronous `afc_get_file_info` packet round-trip over the USB cable.
 
 Look at what our previous one-liner asked the iPhone to do:
 
@@ -3650,7 +3650,7 @@ Target: foo_files.py
 ### 3. DANGLING
 
 * **Article ECID Sanitization**: Run `:'<,'>s/<16-HEX-ECID>/0000REDACTEDECID/ge` on the article stage (or let a rule in `~/.config/pipulate/pii_substitutions.txt` scrub `<16-HEX-ECID> === 0000REDACTEDECID` during `article`).
-* **MathJax Single-to-Double Dollar Port & TTS "Dollar Dollar" Cleanup (`P0.10`)**: Port `init.lua`'s shadow-masked `$expr$` $\rightarrow$ `$$expr$$` converter into `scripts/articles/sanitizer.py` (plus a corpus sweep for backlogged `_posts`) and strip `$$` / translate LaTeX math in `remotes/honeybot/scripts/content_loader.py` so Piper TTS stops speaking `"dollar dollar"`.
+* **MathJax Single-to-Double Dollar Port & TTS "Dollar Dollar" Cleanup (`P0.10`)**: Port `init.lua`'s shadow-masked `$expr$` $$\rightarrow$$ `$$expr$$` converter into `scripts/articles/sanitizer.py` (plus a corpus sweep for backlogged `_posts`) and strip `$$` / translate LaTeX math in `remotes/honeybot/scripts/content_loader.py` so Piper TTS stops speaking `"dollar dollar"`.
 * **Optional `udev` Rule for Automatic `bConfigurationValue = 4**`: Currently `iphone` switches `bConfigurationValue` from `1 -> 4` on demand; an optional `services.udev.extraRules` entry could trigger that configuration switch automatically on USB hotplug.
 
 ---
@@ -3674,7 +3674,7 @@ foo_files.py
 
 There is a world of difference between hating a walled garden from the outside because you are locked out, and enjoying the garden because you hold the master key in your own pocket.
 
-Most modern computing teaches learned helplessness: when a cable doesn't mount a phone, or when two notation systems collide—whether it is `3-12` vs. `3-8` in Linux USB logs, $\frac{dy}{dx}$ in a calculus classroom, or `ER = EPR` across 78 years of theoretical physics—the priesthood expects you to shrug, pay the toll, and rent a cloud intermediary to move your own bytes from your own right hand to your own left hand.
+Most modern computing teaches learned helplessness: when a cable doesn't mount a phone, or when two notation systems collide—whether it is `3-12` vs. `3-8` in Linux USB logs, $$\frac{dy}{dx}$$ in a calculus classroom, or `ER = EPR` across 78 years of theoretical physics—the priesthood expects you to shrug, pay the toll, and rent a cloud intermediary to move your own bytes from your own right hand to your own left hand.
 
 What we did in this article was refuse the intermediary. Using Penn & Teller's transparent plastic cups—a plain-text NixOS configuration, a few lines of Lua and Bash, and a disciplined before-and-after falsification loop—we looked straight down the wire into an iPhone running iOS Lockdown Mode, spotted the exact USB configuration integer holding the gate shut, flipped it from `1` to `4`, pulled a 1.3-megabyte photo across a POSIX FUSE mount in under a second, and stamped the whole ritual into a single 6-letter Forever Machine command: `iphone`.
 
(nix) trimnoir $