site: /for/{slug}/ pages redirect to live generator, retiring stale static pricing

The 195 /for/{slug}/ bundle pages were pre-pivot product artifacts:
$7.99/mo pricing, '14-day trial' CTAs pointing at a /pricing/ page
that no longer has a trial, SaaS-shaped offers that don't match the
current desktop product. Every one was a factually wrong landing for
visitors arriving via SEO. Fixing them individually would be 195
find-and-replace edits that still wouldn't match the live product's
value proposition.

This ships the alternative: retire the static pages entirely and
redirect visitors to the live bundle generator with a pre-filled
business description, producing an up-to-date result card that
matches current product reality.

Three moving parts:

  site/index.html — homepage ?q= URL parameter handler (and
  static/index.html via make site-sync)
    - On page load, reads ?q=<string> from the querystring
    - If present, length-valid (3-500 chars), pre-fills the input,
      auto-submits, and replaces the URL to /? so reload doesn't
      re-trigger and the sharable URL is clean
    - Wrapped in try/catch so ancient browsers without
      URLSearchParams just see the normal homepage
    - Reuses the existing submit() code path entirely — same
      render, counter bump, GA4 event, error handling, timeout,
      offline state

  internal/site/recommend.go — BundleQuery() helper + override map
    - BundleQuery(slug) returns (query, true) for the 195 known
      bundle slugs in bundles.json, defaulting to the bundle Name
      field ("Breweries & Distilleries" for brewery,
      "Therapists & Counselors" for therapist, etc.)
    - bundleQueryOverrides{} holds slug-specific overrides for
      slugs where the bundle Name produces ambiguous LLM output.
      Currently one entry: ark-rust → "ARK and Rust video game
      server administration" (without override, the LLM reads
      "Rust" as the programming language and produces a gamedev
      toolkit)

  internal/site/site.go — /for/{slug}/ route handler
    - orphanBundleSlugs{} identifies 3 /for/ dirs without
      bundles.json entries (self-hosters, solo-developers,
      startups) — pre-pivot artifacts that can't be routed to the
      generator
    - In the /for/ handler, before falling through to static file
      serve: if the slug matches a known bundle, 302 redirect to
      /?q=<url-encoded-query>. If it's an orphan, 302 to /desktop/.
    - Preserved as-is: the /for/ index page (canonical
      browse-all-bundles), /for/{slug}/install.sh (real endpoint
      for desktop install), AI-generated cache serve for unknown
      slugs

Design choices:

  302 not 301 during rollout. 301s cache in browsers indefinitely —
  a bug in the redirect would leave affected users stuck on bad
  redirects until they manually clear their cache. 302 is
  recoverable. Upgrade to 301 in a followup after confirming this
  has been running cleanly for a week.

  Pre-verification of all 195 slugs against live /api/recommend
  before shipping. Every slug produces ≥4 tools and a coherent
  title. The one exception (ark-rust) is handled by override.
  Audit data in /tmp/prewarm-results.jsonl (off-repo).

  Orphan slugs redirect to /desktop/ (the install page) rather
  than the homepage generator. The LLM can't coherently generate
  a toolkit for "self-hosters" — it isn't a business description.
  /desktop/ is the next-best destination (pricing + install CTAs
  they can act on).

What's NOT in this change:

  - The underlying static site/for/{slug}/index.html files still
    exist. They're unreachable now for the 195 + 3 redirected
    slugs, but the files weren't deleted. Deletion is a separate
    followup (keeping them lets us flip the redirect off quickly if
    needed for debugging).
  - No test coverage for the redirect behavior. Existing site-
    package tests run against Register(mux, nil) where db==nil
    means recommender==nil, so the redirect branch doesn't fire
    in test context. Building a test helper that stands up a
    Recommender with in-memory DB is a worthwhile followup.

Verification:
  - go build ./internal/site/...: clean
  - go vet ./internal/site/...: clean
  - go test ./internal/site/...: all existing tests pass (including
    TestNoDuplicateRoutes which catches accidental route conflicts)
  - Secret scan: 0 hits
  - URL encoding sanity-checked: 'Breweries & Distilleries' →
    /?q=Breweries+%26+Distilleries (correct Go url.QueryEscape
    output matches Python urllib quote_plus)

Rollback if a bad redirect escapes the 195-slug audit:
  git revert HEAD && git push. ~170s redeploy. The 302 (not 301)
  means browsers won't hold the bad redirect after the revert.

Author: claude

internal/site/recommend.go

@@ -318,6 +318,44 @@ func (r *Recommender) loadBundles() {
 	log.Printf("[recommend] loaded %d static bundles for install fallback", len(r.bundles))
 }
 
+// bundleQueryOverrides maps slugs that need a custom natural-language
+// query to something different from their bundles.json Name field. Used
+// by BundleQuery for slugs where the bundle name produces ambiguous or
+// off-topic LLM output.
+//
+// `ark-rust`: the bundle Name is "ARK / Rust Server Admins". The LLM
+// reads "Rust" as the programming language and returns a dev toolkit
+// instead of a game-server toolkit. Override to disambiguate.
+//
+// Keep this map small. Most slugs should work with their bundle Name
+// verbatim. Add entries only with a verified before/after test.
+var bundleQueryOverrides = map[string]string{
+	"ark-rust": "ARK and Rust video game server administration",
+}
+
+// BundleQuery returns the natural-language query string to send to
+// /api/recommend for a given bundle slug, and whether the slug is a
+// known bundle. Returns (query, true) if the slug is in bundles.json
+// (the /for/{slug}/ redirect handler uses this to route visitors from
+// the static bundle pages to the live generator). Returns ("", false)
+// for unknown slugs.
+//
+// For most slugs, the query is the bundle's Name field from
+// bundles.json (e.g. "Breweries & Distilleries" for slug "brewery").
+// Slugs in bundleQueryOverrides get a custom query instead.
+func (r *Recommender) BundleQuery(slug string) (string, bool) {
+	if override, ok := bundleQueryOverrides[slug]; ok {
+		return override, true
+	}
+	r.mu.RLock()
+	b, ok := r.bundles[slug]
+	r.mu.RUnlock()
+	if !ok || b == nil || b.Name == "" {
+		return "", false
+	}
+	return b.Name, true
+}
+
 // synthesizeResultForBundle builds a RecommendResult from a static
 // bundles.json entry. Used by GenerateInstallScript when the slug is a
 // known catalog bundle but has no LLM-cached result yet. The synthesized

internal/site/site.go

@@ -12,6 +12,7 @@ import (
 	"log"
 	"net"
 	"net/http"
+	"net/url"
 	"path"
 	"strings"
 	"sync"
@@ -21,6 +22,20 @@ import (
 //go:embed static
 var staticFiles embed.FS
 
+// orphanBundleSlugs are /for/{slug}/ directories with static pages
+// from a pre-pivot product shape that have no matching bundle in
+// bundles.json. They exist as directories in site/for/ because the
+// pages were left in place, but the /for/ handler redirects them to
+// /desktop/ rather than serving the stale content or attempting to
+// run them through the bundle generator (which can't produce a
+// coherent result for "self-hosters" or "startups" — those aren't
+// business descriptions).
+var orphanBundleSlugs = map[string]struct{}{
+	"self-hosters":     {},
+	"solo-developers":  {},
+	"startups":         {},
+}
+
 const affiliateSchema = `
 CREATE TABLE IF NOT EXISTS affiliates (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -389,6 +404,58 @@ func Register(mux *http.ServeMux, db *sql.DB) {
 		} else {
 			path = path + "/index.html"
 		}
+
+		// Bundle slug redirect — if the path is /for/{slug}/ (or
+		// /for/{slug}) and the slug matches a bundle in bundles.json,
+		// 301 to the homepage with ?q=<natural-language-query>. This
+		// retires the 195 static pages with stale pricing (pre-pivot
+		// product shape, $7.99/mo, 14-day trial CTAs) in favor of a
+		// live generator result that matches current product reality.
+		//
+		// The homepage /?q= handler (in site/index.html) auto-submits
+		// the query and renders the result card inline. For visitors
+		// whose LLM call fails, the homepage renders its offline state.
+		//
+		// The /for/ index page itself and /for/{slug}/install.sh are
+		// intentionally NOT redirected — the index is still the
+		// canonical browse-all-bundles page, and install.sh is a real
+		// endpoint used by the desktop install flow.
+		//
+		// All 195 slugs were pre-verified against /api/recommend to
+		// produce ≥4 tools and a coherent title. See BundleQuery in
+		// recommend.go for the overrides table (currently: ark-rust).
+		//
+		// Orphan slugs (self-hosters, solo-developers, startups) are
+		// pages from a pre-pivot product shape with no matching entry
+		// in bundles.json. They redirect to /desktop/ — the generator
+		// can't produce a bundle for "self-hosters" because it isn't a
+		// business description.
+		//
+		// Using 302 (not 301) intentionally during initial rollout:
+		// 301s cache in browsers indefinitely, making any bug in the
+		// redirect logic effectively permanent for affected users
+		// until they clear their cache. 302 gives us a recoverable
+		// deploy. Upgrade to 301 after this has been running cleanly
+		// for a week and we want the SEO benefit.
+		if recommender != nil && strings.HasPrefix(path, "for/") && strings.HasSuffix(path, "/index.html") {
+			slug := strings.TrimSuffix(strings.TrimPrefix(path, "for/"), "/index.html")
+			if slug != "" && slug != "index.html" {
+				if query, ok := recommender.BundleQuery(slug); ok {
+					target := "/?q=" + url.QueryEscape(query)
+					w.Header().Set("Cache-Control", "public, max-age=3600")
+					http.Redirect(w, r, target, http.StatusFound)
+					return
+				}
+				// Orphan slug — redirect to /desktop/ rather than
+				// serve the stale static page.
+				if _, orphan := orphanBundleSlugs[slug]; orphan {
+					w.Header().Set("Cache-Control", "public, max-age=3600")
+					http.Redirect(w, r, "/desktop/", http.StatusFound)
+					return
+				}
+			}
+		}
+
 		data, err := fs.ReadFile(sub, path)
 		if err != nil && recommender != nil {
 			// Try AI-generated cached page

internal/site/static/index.html

@@ -1033,6 +1033,45 @@ <h4>Contact</h4>
   // container mutation isn't worth the complexity — just call it from
   // the .then path where we already render the result. See submit().
   window.__stockyardBumpCounter = bumpCounter;
+
+  // URL query parameter handler — lets /for/{slug}/ redirect visitors
+  // to /?q=<natural-language-description> and get a live generator
+  // result instead of a stale static page.
+  //
+  // Shape: if the page loads with ?q=<something>, prefill the input
+  // and auto-submit. Everything downstream (fetch, render, error
+  // handling, counter) runs exactly as if the user typed it.
+  //
+  // Guards:
+  //   - Same length bounds as manual submit (3..500).
+  //   - strip leading/trailing whitespace.
+  //   - Only runs on initial page load; subsequent navigation
+  //     within the SPA doesn't retrigger.
+  //   - History: replaceState to a clean URL after submit so the
+  //     visitor can share a clean link and browser back doesn't
+  //     re-trigger the auto-submit loop.
+  try {
+    var params = new URLSearchParams(window.location.search);
+    var qParam = params.get('q');
+    if (qParam){
+      qParam = qParam.trim();
+      if (qParam.length >= 3 && qParam.length <= 500){
+        input.value = qParam;
+        // Replace the URL to remove ?q= so refreshing doesn't re-trigger
+        // and so the shared URL is clean.
+        if (window.history && window.history.replaceState){
+          window.history.replaceState({}, '', window.location.pathname);
+        }
+        // Defer to next tick so the above render/counter setup completes.
+        setTimeout(function(){ submit(qParam); }, 0);
+      }
+    }
+  } catch (e) {
+    // URLSearchParams unavailable in ancient browsers. Not worth a
+    // polyfill for this feature — a visitor on IE11 can still use
+    // the homepage manually, they just won't get auto-submit.
+    console.warn('URL param handler skipped:', e);
+  }
 })();
 </script>
 

site/index.html

@@ -1033,6 +1033,45 @@ <h4>Contact</h4>
   // container mutation isn't worth the complexity — just call it from
   // the .then path where we already render the result. See submit().
   window.__stockyardBumpCounter = bumpCounter;
+
+  // URL query parameter handler — lets /for/{slug}/ redirect visitors
+  // to /?q=<natural-language-description> and get a live generator
+  // result instead of a stale static page.
+  //
+  // Shape: if the page loads with ?q=<something>, prefill the input
+  // and auto-submit. Everything downstream (fetch, render, error
+  // handling, counter) runs exactly as if the user typed it.
+  //
+  // Guards:
+  //   - Same length bounds as manual submit (3..500).
+  //   - strip leading/trailing whitespace.
+  //   - Only runs on initial page load; subsequent navigation
+  //     within the SPA doesn't retrigger.
+  //   - History: replaceState to a clean URL after submit so the
+  //     visitor can share a clean link and browser back doesn't
+  //     re-trigger the auto-submit loop.
+  try {
+    var params = new URLSearchParams(window.location.search);
+    var qParam = params.get('q');
+    if (qParam){
+      qParam = qParam.trim();
+      if (qParam.length >= 3 && qParam.length <= 500){
+        input.value = qParam;
+        // Replace the URL to remove ?q= so refreshing doesn't re-trigger
+        // and so the shared URL is clean.
+        if (window.history && window.history.replaceState){
+          window.history.replaceState({}, '', window.location.pathname);
+        }
+        // Defer to next tick so the above render/counter setup completes.
+        setTimeout(function(){ submit(qParam); }, 0);
+      }
+    }
+  } catch (e) {
+    // URLSearchParams unavailable in ancient browsers. Not worth a
+    // polyfill for this feature — a visitor on IE11 can still use
+    // the homepage manually, they just won't get auto-submit.
+    console.warn('URL param handler skipped:', e);
+  }
 })();
 </script>