From 98c0c75e348024ac35086c681b150ab0089afbfb Mon Sep 17 00:00:00 2001
From: dommango-sys <251805093+dommango@users.noreply.github.com>
Date: Mon, 31 Aug 2026 14:20:41 -0400
Subject: [PATCH 1/4] fix: wire build secrets into the Pages deploy, hide
 unconfigured chat

The deploy build never received EMAILJS/reCAPTCHA/GoatCounter env vars, so
the live contact form and analytics have been dead since deploy. Passes the
existing GitHub secrets into the build step and fails loudly via a new
check-build-env.js guard if any required one is missing. Also removes the
misleading to_name/to_email EmailJS params (the template controls the real
recipient) and stops rendering the chat widget when no chat API is
configured, so it can't keep giving wrong offline answers until plan 06
replaces it. fetch-substack.js gets a browser-like User-Agent and a JSON
API fallback for when the RSS route is challenged.
---
 .github/workflows/deploy.yml          | 13 +++++
 __tests__/parse-substack-json.test.ts | 78 +++++++++++++++++++++++++++
 app/layout.tsx                        |  3 +-
 lib/services/emailjs.ts               |  2 -
 scripts/check-build-env.js            | 16 ++++++
 scripts/fetch-substack.js             | 71 ++++++++++++++++--------
 scripts/lib/parse-substack-feed.js    |  2 +-
 scripts/lib/parse-substack-json.js    | 46 ++++++++++++++++
 8 files changed, 204 insertions(+), 27 deletions(-)
 create mode 100644 __tests__/parse-substack-json.test.ts
 create mode 100644 scripts/check-build-env.js
 create mode 100644 scripts/lib/parse-substack-json.js

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index e8e3ece..ac75e5d 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -42,7 +42,20 @@ jobs:
       - name: Fetch Substack posts
         run: node scripts/fetch-substack.js
 
+      - name: Check required build env
+        env:
+          NEXT_PUBLIC_EMAILJS_SERVICE_ID: ${{ secrets.NEXT_PUBLIC_EMAILJS_SERVICE_ID }}
+          NEXT_PUBLIC_EMAILJS_TEMPLATE_ID: ${{ secrets.NEXT_PUBLIC_EMAILJS_TEMPLATE_ID }}
+          NEXT_PUBLIC_EMAILJS_PUBLIC_KEY: ${{ secrets.NEXT_PUBLIC_EMAILJS_PUBLIC_KEY }}
+        run: node scripts/check-build-env.js
+
       - name: Build Next.js
+        env:
+          NEXT_PUBLIC_EMAILJS_SERVICE_ID: ${{ secrets.NEXT_PUBLIC_EMAILJS_SERVICE_ID }}
+          NEXT_PUBLIC_EMAILJS_TEMPLATE_ID: ${{ secrets.NEXT_PUBLIC_EMAILJS_TEMPLATE_ID }}
+          NEXT_PUBLIC_EMAILJS_PUBLIC_KEY: ${{ secrets.NEXT_PUBLIC_EMAILJS_PUBLIC_KEY }}
+          NEXT_PUBLIC_RECAPTCHA_SITE_KEY: ${{ secrets.NEXT_PUBLIC_RECAPTCHA_SITE_KEY }}
+          NEXT_PUBLIC_GOATCOUNTER_SITE: ${{ secrets.GOATCOUNTER_SITE }}
         run: npm run build
 
       - name: Upload artifact
diff --git a/__tests__/parse-substack-json.test.ts b/__tests__/parse-substack-json.test.ts
new file mode 100644
index 0000000..a4cbab8
--- /dev/null
+++ b/__tests__/parse-substack-json.test.ts
@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest'
+import { parseSubstackJson } from '../scripts/lib/parse-substack-json'
+
+const post = (overrides: Partial<Record<string, unknown>> = {}) => ({
+  title: 'Shipping with Claude',
+  canonical_url: 'https://x.substack.com/p/a',
+  post_date: '2026-07-06T12:00:00.000Z',
+  subtitle: 'How it went',
+  ...overrides,
+})
+
+describe('parseSubstackJson', () => {
+  it('extracts posts from a real posts list', () => {
+    const posts = parseSubstackJson(JSON.stringify([post()]))
+
+    expect(posts).toEqual([
+      {
+        title: 'Shipping with Claude',
+        url: 'https://x.substack.com/p/a',
+        date: '2026-07-06T12:00:00.000Z',
+        subtitle: 'How it went',
+      },
+    ])
+  })
+
+  // Same rule as the RSS path: this placeholder must never light up the
+  // dormant Writing section.
+  it('filters out the "Coming soon" placeholder', () => {
+    const posts = parseSubstackJson(JSON.stringify([post({ title: 'Coming soon' })]))
+
+    expect(posts).toEqual([])
+  })
+
+  it('returns newest first', () => {
+    const posts = parseSubstackJson(
+      JSON.stringify([
+        post({ title: 'Older', canonical_url: 'https://x.substack.com/p/1', post_date: '2026-06-01T12:00:00.000Z' }),
+        post({ title: 'Newer', canonical_url: 'https://x.substack.com/p/2', post_date: '2026-07-06T12:00:00.000Z' }),
+      ])
+    )
+
+    expect(posts?.map((p) => p.title)).toEqual(['Newer', 'Older'])
+  })
+
+  it('drops items missing a required field', () => {
+    const posts = parseSubstackJson(JSON.stringify([post({ title: '' }), post({ canonical_url: '' })]))
+
+    expect(posts).toEqual([])
+  })
+
+  it('drops items with an unparseable post_date', () => {
+    const posts = parseSubstackJson(JSON.stringify([post({ post_date: 'not-a-date' })]))
+
+    expect(posts).toEqual([])
+  })
+
+  it('omits the subtitle entirely when absent', () => {
+    const posts = parseSubstackJson(JSON.stringify([post({ subtitle: undefined })]))
+
+    expect(posts?.[0]).not.toHaveProperty('subtitle')
+  })
+
+  // The distinction the caller depends on: [] may overwrite the committed
+  // POSTS, null may not.
+  it('returns [] for a real empty list', () => {
+    expect(parseSubstackJson('[]')).toEqual([])
+  })
+
+  it('returns null when the body is not a posts list at all', () => {
+    expect(parseSubstackJson('<html><body>not json</body></html>')).toBeNull()
+    expect(parseSubstackJson('{"error": "not found"}')).toBeNull()
+    expect(parseSubstackJson('')).toBeNull()
+  })
+
+  it('does not throw on malformed JSON', () => {
+    expect(() => parseSubstackJson('{broken')).not.toThrow()
+  })
+})
diff --git a/app/layout.tsx b/app/layout.tsx
index 48c5c3a..d616f9b 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -11,6 +11,7 @@ import { ChatBot } from "@/components/chat/ChatBot";
 import "./globals.css";
 
 const GOATCOUNTER_SITE = process.env.NEXT_PUBLIC_GOATCOUNTER_SITE;
+const CHAT_API_URL = process.env.NEXT_PUBLIC_CHAT_API_URL;
 const SITE_URL = "https://dommango.github.io";
 
 const geistSans = Geist({
@@ -99,7 +100,7 @@ export default function RootLayout({
         className={`${geistSans.variable} ${geistMono.variable} ${archivoBlack.variable} ${spaceGrotesk.variable} ${jetbrainsMono.variable} antialiased`}
       >
         {children}
-        <ChatBot />
+        {CHAT_API_URL && <ChatBot />}
         {GOATCOUNTER_SITE && (
           <Script
             data-goatcounter={`https://${GOATCOUNTER_SITE}.goatcounter.com/count`}
diff --git a/lib/services/emailjs.ts b/lib/services/emailjs.ts
index 6e552a5..cdc048c 100644
--- a/lib/services/emailjs.ts
+++ b/lib/services/emailjs.ts
@@ -55,8 +55,6 @@ export async function sendContactEmail({
       {
         from_name: fromName,
         from_email: fromEmail,
-        to_name: fromName,
-        to_email: fromEmail,
         reply_to: fromEmail,
         message
       }
diff --git a/scripts/check-build-env.js b/scripts/check-build-env.js
new file mode 100644
index 0000000..f2ece10
--- /dev/null
+++ b/scripts/check-build-env.js
@@ -0,0 +1,16 @@
+// Fails the deploy build when a NEXT_PUBLIC_* value the site needs is missing.
+// Local builds don't run this (see deploy.yml), so `npm run build` still works
+// without a .env.local.
+const REQUIRED = [
+  'NEXT_PUBLIC_EMAILJS_SERVICE_ID',
+  'NEXT_PUBLIC_EMAILJS_TEMPLATE_ID',
+  'NEXT_PUBLIC_EMAILJS_PUBLIC_KEY',
+]
+
+const missing = REQUIRED.filter((k) => !process.env[k])
+if (missing.length > 0) {
+  console.error(`[env] missing required build env: ${missing.join(', ')}`)
+  console.error('[env] set them with `gh secret set <NAME>` — see docs/plans/01-reconnect-live-plumbing.md')
+  process.exit(1)
+}
+console.log('[env] all required build env present')
diff --git a/scripts/fetch-substack.js b/scripts/fetch-substack.js
index 1e6d15a..b26693b 100644
--- a/scripts/fetch-substack.js
+++ b/scripts/fetch-substack.js
@@ -9,8 +9,17 @@
 const fs = require('fs')
 const path = require('path')
 const { parseSubstackFeed } = require('./lib/parse-substack-feed')
-
-const FEED_URL = 'https://dommangonon.substack.com/feed'
+const { parseSubstackJson } = require('./lib/parse-substack-json')
+
+const FEED_URLS = [
+  'https://dommangonon.substack.com/feed',
+  // Substack's JSON API sometimes answers when the RSS route is challenged.
+  'https://dommangonon.substack.com/api/v1/posts?limit=6',
+]
+const HEADERS = {
+  'user-agent': 'Mozilla/5.0 (compatible; dommango.github.io build; +https://dommango.github.io)',
+  accept: 'application/rss+xml, application/xml, application/json;q=0.9, */*;q=0.8',
+}
 const TARGET = path.join(__dirname, '../lib/content/writing.ts')
 const MAX_POSTS = 6
 const MARKER = '// GENERATED — do not edit by hand. See scripts/fetch-substack.js.'
@@ -37,36 +46,52 @@ const serialize = (posts) => {
   return `export const POSTS: WritingPost[] = [\n${entries}\n]`
 }
 
-async function main() {
-  let posts = []
+// Fetches and parses a single source. Returns null (try the next source) on
+// any failure — non-2xx, unparseable body, or a body that isn't actually a
+// posts list (see parseSubstackFeed/parseSubstackJson doc comments).
+async function fetchPosts(url) {
+  const response = await fetch(url, { headers: HEADERS, signal: AbortSignal.timeout(15000) })
 
-  try {
-    const response = await fetch(FEED_URL, {
-      headers: { 'user-agent': 'dommango.github.io build' },
-      signal: AbortSignal.timeout(15000),
-    })
+  if (!response.ok) {
+    console.warn(`[substack] ${url} returned ${response.status}`)
+    return null
+  }
 
-    if (!response.ok) {
-      console.warn(`[substack] feed returned ${response.status}; keeping committed posts`)
-      return
-    }
+  const body = await response.text()
+  const parsed = url.includes('/api/v1/posts') ? parseSubstackJson(body) : parseSubstackFeed(body)
 
-    const parsed = parseSubstackFeed(await response.text())
+  if (parsed === null) {
+    console.warn(`[substack] ${url} response was not a posts feed`)
+    return null
+  }
+
+  return parsed
+}
 
-    // null means the body wasn't a feed — a 200 carrying an interstitial or a
-    // login page. Writing [] there would silently empty the Writing section on
-    // a cron build nobody is watching, so treat it like any other outage.
-    if (parsed === null) {
-      console.warn('[substack] response was not an RSS feed; keeping committed posts')
-      return
+async function main() {
+  let posts = null
+
+  for (const url of FEED_URLS) {
+    try {
+      posts = await fetchPosts(url)
+    } catch (error) {
+      console.warn(`[substack] fetch failed for ${url} (${error.message})`)
+      posts = null
     }
+    if (posts !== null) break
+  }
 
-    posts = parsed.slice(0, MAX_POSTS)
-  } catch (error) {
-    console.warn(`[substack] fetch failed (${error.message}); keeping committed posts`)
+  // null after every source means an outage — a 200 carrying an interstitial
+  // or a login page counts too. Writing [] there would silently empty the
+  // Writing section on a cron build nobody is watching, so keep committed
+  // posts instead, same as any other failure.
+  if (posts === null) {
+    console.warn('[substack] all sources failed; keeping committed posts')
     return
   }
 
+  posts = posts.slice(0, MAX_POSTS)
+
   const source = fs.readFileSync(TARGET, 'utf8')
   const markerIndex = source.indexOf(MARKER)
   const endIndex = source.indexOf(END_MARKER)
diff --git a/scripts/lib/parse-substack-feed.js b/scripts/lib/parse-substack-feed.js
index 50d096b..b0fe35d 100644
--- a/scripts/lib/parse-substack-feed.js
+++ b/scripts/lib/parse-substack-feed.js
@@ -85,4 +85,4 @@ function parseSubstackFeed(xml) {
     .sort((a, b) => b.date.localeCompare(a.date))
 }
 
-module.exports = { parseSubstackFeed }
+module.exports = { parseSubstackFeed, isPlaceholder }
diff --git a/scripts/lib/parse-substack-json.js b/scripts/lib/parse-substack-json.js
new file mode 100644
index 0000000..a4b4113
--- /dev/null
+++ b/scripts/lib/parse-substack-json.js
@@ -0,0 +1,46 @@
+// Pure JSON -> posts transform for Substack's `/api/v1/posts` endpoint, used
+// as a fallback when the RSS route is challenged. Mirrors parse-substack-feed.js:
+// null means the body wasn't a posts list at all, [] means a real list with
+// nothing publishable.
+
+const { isPlaceholder } = require('./parse-substack-feed')
+
+const toIsoDate = (value) => {
+  if (!value) return null
+  const parsed = new Date(value)
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString()
+}
+
+/**
+ * @param {string} body Raw JSON response body.
+ * @returns {Array<{title: string, url: string, date: string, subtitle?: string}>|null}
+ *   Real posts newest first, [] for a list with none, or null if the body
+ *   isn't a posts list at all.
+ */
+function parseSubstackJson(body) {
+  let parsed
+  try {
+    parsed = JSON.parse(body)
+  } catch {
+    return null
+  }
+
+  if (!Array.isArray(parsed)) return null
+
+  return parsed
+    .map((item) => {
+      const title = typeof item?.title === 'string' ? item.title.trim() : ''
+      const url = typeof item?.canonical_url === 'string' ? item.canonical_url.trim() : ''
+      const date = toIsoDate(item?.post_date)
+      const subtitle = typeof item?.subtitle === 'string' ? item.subtitle.trim() : ''
+
+      if (!title || !url || !date) return null
+      if (isPlaceholder(title)) return null
+
+      return subtitle ? { title, url, date, subtitle } : { title, url, date }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.date.localeCompare(a.date))
+}
+
+module.exports = { parseSubstackJson }

From a115aff32a9bb8cf2ba669b93bb342fea5d510f4 Mon Sep 17 00:00:00 2001
From: dommango-sys <251805093+dommango@users.noreply.github.com>
Date: Mon, 31 Aug 2026 14:20:46 -0400
Subject: [PATCH 2/4] chore: commit the Aug 4 Substack post so Writing renders
 on deploy
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The CI fetch gets a 403 from Substack's GitHub Actions IP range, so the
committed POSTS array is the reliable path — it's what ships whenever the
cron/build fetch fails, which is currently always. Fetched from a
residential connection per docs/plans/01-reconnect-live-plumbing.md.
---
 lib/content/writing.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/content/writing.ts b/lib/content/writing.ts
index ab954d6..27269f5 100644
--- a/lib/content/writing.ts
+++ b/lib/content/writing.ts
@@ -18,7 +18,14 @@ export interface WritingPost {
 export const SUBSTACK_URL = 'https://dommangonon.substack.com'
 
 // GENERATED — do not edit by hand. See scripts/fetch-substack.js.
-export const POSTS: WritingPost[] = []
+export const POSTS: WritingPost[] = [
+  {
+    title: "The game had already started",
+    url: "https://dommangonon.substack.com/p/the-game-had-already-started",
+    date: "2026-08-04T15:49:40.000Z",
+    subtitle: "What I learned shipping a bracket-pool app for my friends' World Cup pool &#8212; while the World Cup was being played.",
+  },
+]
 // END GENERATED
 
 export const hasPosts = (): boolean => POSTS.length > 0

From d99805b8bc88a29da584d63115024452ebea4cc1 Mon Sep 17 00:00:00 2001
From: dommango-sys <251805093+dommango@users.noreply.github.com>
Date: Mon, 31 Aug 2026 14:22:08 -0400
Subject: [PATCH 3/4] test: update /blog 404 e2e test now that a Substack post
 exists

Plan 07's test assumed hasPosts() was false; plan 01 commits the first
real post, so /blog is now a genuine redirect target instead of the
dangling-anchor case the old test guarded against.
---
 e2e/not-found.spec.ts | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/e2e/not-found.spec.ts b/e2e/not-found.spec.ts
index 43570bd..424d96a 100644
--- a/e2e/not-found.spec.ts
+++ b/e2e/not-found.spec.ts
@@ -16,15 +16,14 @@ test.describe("Custom 404", () => {
     await expect(page.locator("#resume")).toBeInViewport();
   });
 
-  test("old /blog URL gets a plain 404 when there are no posts yet", async ({ page }) => {
-    // There's no Writing section to rescue this to until a post ships
-    // (see lib/content/writing.ts POSTS), so it must not redirect to a
-    // dangling #writing anchor.
+  test("old /blog URL redirects to the writing section now that a post exists", async ({ page }) => {
+    // lib/content/writing.ts POSTS is non-empty as of plan 01, so /blog is a
+    // real redirect target, not the dangling-anchor case this used to guard.
     await page.goto("/blog");
-    await expect(page.getByRole("heading", { name: /nothing here/i })).toBeVisible();
-    await expect(page.getByRole("link", { name: "Writing →" })).toHaveCount(0);
-    await page.waitForTimeout(1500);
-    expect(page.url()).toContain("/blog");
+    await expect(page.getByRole("heading", { name: /that page moved/i })).toBeVisible();
+    await expect(page.getByRole("status")).toContainText(/redirecting to writing/i);
+    await page.waitForURL(/\/#writing$/, { timeout: 10000 });
+    await expect(page.locator("#writing")).toBeInViewport();
   });
 
   test("unknown paths get a plain 404 with no redirect", async ({ page }) => {

From d72d7e14727c913a8cae39e1f6164a00164f27e3 Mon Sep 17 00:00:00 2001
From: dommango-sys <251805093+dommango@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:29:32 -0400
Subject: [PATCH 4/4] fix: address code review on the plumbing reconnect
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Decode HTML entities (numeric + named) in the RSS subtitle, not just
  &nbsp; — the live feed's em dashes were rendering as literal "&#8212;"
  on the one post this plan turns on.
- Treat a bare [] from the JSON fallback as inconclusive (null), same as
  the RSS parser does for a body that isn't a real feed — this source has
  no way to confirm "genuinely zero posts" and shouldn't be allowed to
  empty the committed POSTS on a shape drift.
- Collapse the guard + build into one env block in deploy.yml so a var
  added to only one of them can't silently pass the guard while missing
  from the actual build; add NEXT_PUBLIC_GOATCOUNTER_SITE to the
  required list (analytics was one of the three things this plan exists
  to fix).
- Pair each fetch source with its parser directly (SOURCES tuples)
  instead of dispatching on a url.includes() check that could drift.
- Route ChatBot through a client-only ChatBotGate using next/dynamic, so
  the stale offline-answer copy it ships is excluded from the bundle
  entirely while chat is unconfigured, not just unrendered.
- Add the missing positive-branch test for hasPosts() in
  not-found-redirects.test.ts, and correct CLAUDE.md's ChatBot line.
---
 .github/workflows/deploy.yml          | 12 ++++--------
 CLAUDE.md                             |  2 +-
 __tests__/not-found-redirects.test.ts |  7 +++++++
 __tests__/parse-substack-feed.test.ts | 19 +++++++++++++++++++
 __tests__/parse-substack-json.test.ts | 10 ++++++----
 app/layout.tsx                        |  4 ++--
 components/chat/ChatBotGate.tsx       | 14 ++++++++++++++
 lib/content/writing.ts                |  2 +-
 scripts/check-build-env.js            |  1 +
 scripts/fetch-substack.js             | 18 ++++++++++--------
 scripts/lib/parse-substack-feed.js    | 19 +++++++++++++++++--
 scripts/lib/parse-substack-json.js    |  7 ++++++-
 12 files changed, 88 insertions(+), 27 deletions(-)
 create mode 100644 components/chat/ChatBotGate.tsx

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index ac75e5d..1885bf0 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -42,13 +42,9 @@ jobs:
       - name: Fetch Substack posts
         run: node scripts/fetch-substack.js
 
-      - name: Check required build env
-        env:
-          NEXT_PUBLIC_EMAILJS_SERVICE_ID: ${{ secrets.NEXT_PUBLIC_EMAILJS_SERVICE_ID }}
-          NEXT_PUBLIC_EMAILJS_TEMPLATE_ID: ${{ secrets.NEXT_PUBLIC_EMAILJS_TEMPLATE_ID }}
-          NEXT_PUBLIC_EMAILJS_PUBLIC_KEY: ${{ secrets.NEXT_PUBLIC_EMAILJS_PUBLIC_KEY }}
-        run: node scripts/check-build-env.js
-
+      # One env block feeding both the guard and the build: a var added to
+      # only one of them would either let a real gap through the guard or
+      # make the guard block a build that would have had everything it needs.
       - name: Build Next.js
         env:
           NEXT_PUBLIC_EMAILJS_SERVICE_ID: ${{ secrets.NEXT_PUBLIC_EMAILJS_SERVICE_ID }}
@@ -56,7 +52,7 @@ jobs:
           NEXT_PUBLIC_EMAILJS_PUBLIC_KEY: ${{ secrets.NEXT_PUBLIC_EMAILJS_PUBLIC_KEY }}
           NEXT_PUBLIC_RECAPTCHA_SITE_KEY: ${{ secrets.NEXT_PUBLIC_RECAPTCHA_SITE_KEY }}
           NEXT_PUBLIC_GOATCOUNTER_SITE: ${{ secrets.GOATCOUNTER_SITE }}
-        run: npm run build
+        run: node scripts/check-build-env.js && npm run build
 
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v3
diff --git a/CLAUDE.md b/CLAUDE.md
index 6a9471a..a7d5d88 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -33,7 +33,7 @@ scroll-spy state and composing every section.
 
 ```
 app/
-├── layout.tsx            # Root layout, fonts, metadata/JSON-LD, ChatBot
+├── layout.tsx            # Root layout, fonts, metadata/JSON-LD, ChatBot (only if NEXT_PUBLIC_CHAT_API_URL is set)
 ├── page.tsx              # Loads projects/writing/travel data -> BrutalistLanding
 ├── globals.css           # All styles (see Design System below)
 └── dashboard-m7x9k2/     # Private-ish analytics dashboard (obscure URL, not linked)
diff --git a/__tests__/not-found-redirects.test.ts b/__tests__/not-found-redirects.test.ts
index 86a05f3..a0cf668 100644
--- a/__tests__/not-found-redirects.test.ts
+++ b/__tests__/not-found-redirects.test.ts
@@ -37,4 +37,11 @@ describe('not-found redirect table', () => {
       expect(REDIRECTS.find((r) => r.test.test('/blog'))).toBeUndefined()
     }
   })
+
+  it('offers and redirects to Writing once a post exists', () => {
+    if (hasPosts()) {
+      expect(SECTIONS.some(([label]) => label === 'Writing')).toBe(true)
+      expect(REDIRECTS.find((r) => r.test.test('/blog'))?.to).toBe('/#writing')
+    }
+  })
 })
diff --git a/__tests__/parse-substack-feed.test.ts b/__tests__/parse-substack-feed.test.ts
index 8aa9d30..a9acfd6 100644
--- a/__tests__/parse-substack-feed.test.ts
+++ b/__tests__/parse-substack-feed.test.ts
@@ -140,6 +140,25 @@ describe('parseSubstackFeed', () => {
     expect(posts?.[0].subtitle).toBe('when a < b holds')
   })
 
+  // Substack's CDATA description carries numeric entities (an em dash comes
+  // through as &#8212;), and the fetch-substack pipeline JSON-stringifies the
+  // result, which would double-escape an undecoded "&#8212;" into visible
+  // tag soup on the card.
+  it('decodes numeric and named HTML entities in the subtitle', () => {
+    const posts = parseSubstackFeed(
+      feed(
+        item(
+          'Post',
+          'https://x.substack.com/p/a',
+          'Mon, 06 Jul 2026 12:00:00 GMT',
+          'Before &#8212; after &amp; done'
+        )
+      )
+    )
+
+    expect(posts?.[0].subtitle).toBe('Before — after & done')
+  })
+
   it('omits the subtitle entirely when the description is only markup', () => {
     const posts = parseSubstackFeed(
       feed(item('Post', 'https://x.substack.com/p/a', 'Mon, 06 Jul 2026 12:00:00 GMT', '<p></p>'))
diff --git a/__tests__/parse-substack-json.test.ts b/__tests__/parse-substack-json.test.ts
index a4cbab8..31f3a46 100644
--- a/__tests__/parse-substack-json.test.ts
+++ b/__tests__/parse-substack-json.test.ts
@@ -60,10 +60,12 @@ describe('parseSubstackJson', () => {
     expect(posts?.[0]).not.toHaveProperty('subtitle')
   })
 
-  // The distinction the caller depends on: [] may overwrite the committed
-  // POSTS, null may not.
-  it('returns [] for a real empty list', () => {
-    expect(parseSubstackJson('[]')).toEqual([])
+  // Unlike the RSS parser, this path has no way to tell "the publication has
+  // zero posts" from "the endpoint drifted into some other empty shape" — it
+  // only ever runs after RSS already failed. So a bare [] must not be treated
+  // as authoritative enough to overwrite the committed POSTS.
+  it('returns null for a bare empty array, not []', () => {
+    expect(parseSubstackJson('[]')).toBeNull()
   })
 
   it('returns null when the body is not a posts list at all', () => {
diff --git a/app/layout.tsx b/app/layout.tsx
index d616f9b..0f4999f 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -7,7 +7,7 @@ import {
   Space_Grotesk,
   JetBrains_Mono,
 } from "next/font/google";
-import { ChatBot } from "@/components/chat/ChatBot";
+import { ChatBotGate } from "@/components/chat/ChatBotGate";
 import "./globals.css";
 
 const GOATCOUNTER_SITE = process.env.NEXT_PUBLIC_GOATCOUNTER_SITE;
@@ -100,7 +100,7 @@ export default function RootLayout({
         className={`${geistSans.variable} ${geistMono.variable} ${archivoBlack.variable} ${spaceGrotesk.variable} ${jetbrainsMono.variable} antialiased`}
       >
         {children}
-        {CHAT_API_URL && <ChatBot />}
+        <ChatBotGate enabled={Boolean(CHAT_API_URL)} />
         {GOATCOUNTER_SITE && (
           <Script
             data-goatcounter={`https://${GOATCOUNTER_SITE}.goatcounter.com/count`}
diff --git a/components/chat/ChatBotGate.tsx b/components/chat/ChatBotGate.tsx
new file mode 100644
index 0000000..1339ba7
--- /dev/null
+++ b/components/chat/ChatBotGate.tsx
@@ -0,0 +1,14 @@
+'use client'
+
+import dynamic from 'next/dynamic'
+
+// Lazy so layout.tsx (a server component) never pulls ChatBot — and the
+// stale offline answers baked into lib/services/chat.ts — into the shipped
+// bundle at all while chat is unconfigured. The dynamic import only fires
+// once this component actually renders <ChatBot/>, which `enabled` gates.
+const ChatBot = dynamic(() => import('./ChatBot').then((m) => m.ChatBot), { ssr: false })
+
+export function ChatBotGate({ enabled }: { enabled: boolean }) {
+  if (!enabled) return null
+  return <ChatBot />
+}
diff --git a/lib/content/writing.ts b/lib/content/writing.ts
index 27269f5..b37e8f9 100644
--- a/lib/content/writing.ts
+++ b/lib/content/writing.ts
@@ -23,7 +23,7 @@ export const POSTS: WritingPost[] = [
     title: "The game had already started",
     url: "https://dommangonon.substack.com/p/the-game-had-already-started",
     date: "2026-08-04T15:49:40.000Z",
-    subtitle: "What I learned shipping a bracket-pool app for my friends' World Cup pool &#8212; while the World Cup was being played.",
+    subtitle: "What I learned shipping a bracket-pool app for my friends' World Cup pool — while the World Cup was being played.",
   },
 ]
 // END GENERATED
diff --git a/scripts/check-build-env.js b/scripts/check-build-env.js
index f2ece10..da6478a 100644
--- a/scripts/check-build-env.js
+++ b/scripts/check-build-env.js
@@ -5,6 +5,7 @@ const REQUIRED = [
   'NEXT_PUBLIC_EMAILJS_SERVICE_ID',
   'NEXT_PUBLIC_EMAILJS_TEMPLATE_ID',
   'NEXT_PUBLIC_EMAILJS_PUBLIC_KEY',
+  'NEXT_PUBLIC_GOATCOUNTER_SITE',
 ]
 
 const missing = REQUIRED.filter((k) => !process.env[k])
diff --git a/scripts/fetch-substack.js b/scripts/fetch-substack.js
index b26693b..00b1baf 100644
--- a/scripts/fetch-substack.js
+++ b/scripts/fetch-substack.js
@@ -11,10 +11,13 @@ const path = require('path')
 const { parseSubstackFeed } = require('./lib/parse-substack-feed')
 const { parseSubstackJson } = require('./lib/parse-substack-json')
 
-const FEED_URLS = [
-  'https://dommangonon.substack.com/feed',
+// Each source pairs its URL with the parser that understands its body, so
+// the two can never drift apart the way a separate `url.includes(...)`
+// dispatch could.
+const SOURCES = [
+  { url: 'https://dommangonon.substack.com/feed', parse: parseSubstackFeed },
   // Substack's JSON API sometimes answers when the RSS route is challenged.
-  'https://dommangonon.substack.com/api/v1/posts?limit=6',
+  { url: 'https://dommangonon.substack.com/api/v1/posts?limit=6', parse: parseSubstackJson },
 ]
 const HEADERS = {
   'user-agent': 'Mozilla/5.0 (compatible; dommango.github.io build; +https://dommango.github.io)',
@@ -49,7 +52,7 @@ const serialize = (posts) => {
 // Fetches and parses a single source. Returns null (try the next source) on
 // any failure — non-2xx, unparseable body, or a body that isn't actually a
 // posts list (see parseSubstackFeed/parseSubstackJson doc comments).
-async function fetchPosts(url) {
+async function fetchPosts(url, parse) {
   const response = await fetch(url, { headers: HEADERS, signal: AbortSignal.timeout(15000) })
 
   if (!response.ok) {
@@ -57,8 +60,7 @@ async function fetchPosts(url) {
     return null
   }
 
-  const body = await response.text()
-  const parsed = url.includes('/api/v1/posts') ? parseSubstackJson(body) : parseSubstackFeed(body)
+  const parsed = parse(await response.text())
 
   if (parsed === null) {
     console.warn(`[substack] ${url} response was not a posts feed`)
@@ -71,9 +73,9 @@ async function fetchPosts(url) {
 async function main() {
   let posts = null
 
-  for (const url of FEED_URLS) {
+  for (const { url, parse } of SOURCES) {
     try {
-      posts = await fetchPosts(url)
+      posts = await fetchPosts(url, parse)
     } catch (error) {
       console.warn(`[substack] fetch failed for ${url} (${error.message})`)
       posts = null
diff --git a/scripts/lib/parse-substack-feed.js b/scripts/lib/parse-substack-feed.js
index b0fe35d..fd89a93 100644
--- a/scripts/lib/parse-substack-feed.js
+++ b/scripts/lib/parse-substack-feed.js
@@ -36,10 +36,25 @@ const text = (value) => {
 // it, so the risk isn't XSS — it's a card rendering "<p>Hello <em>world</em></p>"
 // as visible tag soup. Only strip things shaped like a tag, so prose such as
 // "a < b" survives.
-const stripHtml = (value) =>
+const stripTags = (value) => value.replace(/<\/?[a-zA-Z][^>]*>/g, ' ')
+
+// Runs after stripTags, on purpose: a literal "&lt;" that survived tag
+// stripping (it never had a raw "<") should decode to display text, not be
+// mistaken for a tag boundary. Decode &amp; last so "&amp;#8212;" doesn't
+// double-decode into a literal "&#8212;".
+const decodeEntities = (value) =>
   value
-    .replace(/<\/?[a-zA-Z][^>]*>/g, ' ')
+    .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
     .replace(/&nbsp;/g, ' ')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&amp;/g, '&')
+
+const stripHtml = (value) =>
+  decodeEntities(stripTags(value))
     .replace(/\s+/g, ' ')
     .trim()
 
diff --git a/scripts/lib/parse-substack-json.js b/scripts/lib/parse-substack-json.js
index a4b4113..6e3f2fd 100644
--- a/scripts/lib/parse-substack-json.js
+++ b/scripts/lib/parse-substack-json.js
@@ -25,7 +25,12 @@ function parseSubstackJson(body) {
     return null
   }
 
-  if (!Array.isArray(parsed)) return null
+  // This path only runs after RSS already failed, so there's no corroborating
+  // signal for "the publication genuinely has zero posts" the way the RSS
+  // parser gets from a present-but-empty <channel>. Treat a bare [] as
+  // inconclusive (like any other shape this endpoint might drift into)
+  // rather than let it overwrite the committed POSTS.
+  if (!Array.isArray(parsed) || parsed.length === 0) return null
 
   return parsed
     .map((item) => {