GUARANTEE both passes always run + generic fallback for any unmatched industry

User feedback: after onboarding, the edit form was still showing empty fields
because the pipeline was conditional. Three fixes layered:

1. PASS 2 (gap-fill) + PASS 3 (Google search) now ALWAYS run in full mode —
   not gated on whether previous passes left fields empty. Even if pass 1
   filled everything, Google search runs to enrich with reviews / competitor
   mentions / customer language that homepage content never has.

   - Light mode (the user-toggleable cheap path) still skips both passes for
     ~70% cost reduction.
   - Status banner now reads "AI pass 2 — gap-fill" and "AI pass 3 — Google
     search" so the user sees both firing.

2. Industry-fallback now has a GENERIC_FALLBACK template that fires when no
   keyword matches the brand's industry. Previously: industry "cricket
   equipment manufacturer" → no template match → industry-fallback silently
   filled nothing. Now: generic-but-non-empty defaults always fill the form.
   Cross-check is never blank.

3. BrandBrainForm "Fill empty with AI" button now runs the FULL 4-pass
   pipeline (subpages + AI extraction + Google search augmentation +
   industry fallback) instead of just one pass. So users editing an existing
   half-empty brain get the same quality as fresh onboarding.

   The auto-search inside fillEmptyWithAi merges into pass-1 result before
   the final setBrain — preserving user's already-typed values via
   mergeFillEmpty's fill-empty-only semantics.

The auto-search pass merge is now fill-empty-only (search results no longer
overwrite pass-1 results) so the homepage's voice wins for tone / messaging
and the search adds only what was missing (competitors, reviews, audience
language).

Author: IamRamgarhia

app/brand/new/page.tsx

@@ -353,14 +353,19 @@ function Inner() {
         if (typeof v === "string" && !v.trim()) continue;
         merged1[k] = v;
       }
+      // GUARANTEED passes (full mode): we ALWAYS run gap-fill + auto-Google so
+      // every onboarding pulls maximum signal. Light mode skips both.
+      // The "missing" set is computed for prompt-targeting only, not as a gate.
       const missing: string[] = GAP_FILL_FIELDS.filter((f) => isEmptyField(merged1[f]));
-      // objections and objection_handling are paired arrays — if one is missing
-      // we must regenerate both together so the indices line up. (Audit finding #63.)
       if (missing.includes("objections") && !missing.includes("objection_handling")) missing.push("objection_handling");
       if (missing.includes("objection_handling") && !missing.includes("objections")) missing.push("objections");
-      // Light mode skips both gap-fill + auto-search to save cost; pass 1 + industry fallback only.
-      if (missing.length && !lightMode) {
-        setQuickStatus(`⑤ Filling gaps — ${missing.length} field${missing.length === 1 ? "" : "s"} still empty. Re-asking AI to infer from content…`);
+      // Force-include core inference fields if pass 1 was completely empty —
+      // gives the gap-fill prompt a meaningful field list to anchor on.
+      if (missing.length === 0 && Object.keys(parsed).length < 8) {
+        missing.push("tone", "audience_who", "audience_pain_points", "audience_desires", "key_benefits");
+      }
+      if (!lightMode && missing.length) {
+        setQuickStatus(`⑤ AI pass 2 — gap-fill (re-asking for ${missing.length} inference field${missing.length === 1 ? "" : "s"})…`);
         try {
           const gapRes = await llmCall({
             messages: [{ role: "user", content: buildBrandGapFillPrompt({
@@ -401,21 +406,23 @@ function Inner() {
         }
       }
 
-      // Pass 3 — auto Google search. The homepage rarely contains customer
-      // reviews, competitor mentions, or audience language; a Google search
-      // for the brand name pulls in review sites, forums, press — much
-      // richer signal for the inference fields. Only runs if pass 1 + gap-fill
-      // left something empty AND we have a usable brand name to search for.
+      // PASS 3 — ALWAYS runs in full mode (not gated on missing fields). The
+      // homepage rarely contains customer reviews, competitor mentions, or
+      // audience language; Google search pulls review sites, forums, press —
+      // the richest signal for inference fields. Skipped only in light mode.
       const stillMissing = GAP_FILL_FIELDS.filter((f) => isEmptyField(parsed[f]));
+      // For the prompt, target both still-empty fields AND core inference
+      // fields (so search can refine even fields that are already filled).
+      const searchTargets = stillMissing.length
+        ? stillMissing
+        : ["tone", "audience_who", "audience_pain_points", "audience_desires", "key_benefits", "competitors", "objections", "objection_handling", "words_to_use"];
       const searchableName = deterministic.business_name || parsed.business_name;
-      if (stillMissing.length && searchableName && searchableName.length > 2 && !lightMode) {
-        // Build a focused query: brand name + industry keyword to disambiguate
-        // and bias toward reviews / mentions.
+      if (searchableName && searchableName.length > 2 && !lightMode) {
         const industryHint = (deterministic.industry || parsed.industry || "").split(/[|·,]/)[0].trim();
         const baseQuery = industryHint
           ? `${searchableName} ${industryHint} reviews competitors customers`
           : `${searchableName} reviews competitors`;
-        setQuickStatus(`⑥ Auto-searching Google for "${searchableName}" to fill ${stillMissing.length} remaining gap${stillMissing.length === 1 ? "" : "s"}…`);
+        setQuickStatus(`⑥ AI pass 3 — Google search for "${searchableName}" to pull reviews / competitors / customer language…`);
         try {
           const searchUrl = `https://s.jina.ai/${encodeURIComponent(baseQuery)}`;
           const searchRes = await ingestUrl(searchUrl, signal);
@@ -428,7 +435,7 @@ function Inner() {
                 niche: deterministic.niche || parsed.niche,
                 usp: deterministic.usp || parsed.usp,
                 search_content: searchRes.content,
-                missing_fields: stillMissing as unknown as string[],
+                missing_fields: searchTargets as unknown as string[],
               }) }],
               maxTokens: 2500,
               temperature: 0.7,
@@ -440,7 +447,10 @@ function Inner() {
             window.dispatchEvent(new Event("ados:usage"));
             const augParsed = tryParseJson<any>(augRes.text) ?? {};
             dlog("[adforge:brand-extract] parsed AI JSON (search-augmented):", augParsed);
-            for (const f of stillMissing) {
+            // For fields already filled by pass 1+2, search-augmented values
+            // do NOT overwrite — only fills empty fields. Pass 1 result wins.
+            for (const f of searchTargets) {
+              if (!isEmptyField(parsed[f])) continue;
               const coerced = coerceFieldValue(f, augParsed[f]);
               if (!isEmptyField(coerced)) parsed[f] = coerced;
             }

components/BrandBrainForm.tsx

@@ -8,6 +8,7 @@ import { saveBrain } from "@/lib/storage";
 import { setActiveBrainId, addUsage } from "@/lib/settings";
 import { llmCall, estimateCostUsd, tryParseJson } from "@/lib/llm";
 import { buildBrandExtractionPrompt } from "@/lib/prompts/brand-extraction";
+import { buildSearchAugmentedPrompt } from "@/lib/prompts/brand-search-augmented";
 import { ingestUrl, ingestSubpages, detectSocial } from "@/lib/url-ingest";
 import { applyIndustryFallback } from "@/lib/industry-fallback";
 import { deterministicFillFromMetadata } from "@/lib/deterministic-brand-fill";
@@ -195,9 +196,17 @@ export function BrandBrainForm({ initial }: Props) {
     }
   }
 
-  /** "Fill empty with AI" — re-ingests the brand's saved website_url, runs the
-   *  AI extraction, and fills ONLY the fields the user has left blank. Safe
-   *  to click on an in-progress edit without losing manual changes. */
+  /** "Fill empty with AI" — runs the FULL onboarding pipeline against the
+   *  brand's saved website_url and merges into empty fields only. Safe
+   *  to click on an in-progress edit without losing manual changes.
+   *
+   *  Runs the same 4 passes as new-brand onboarding:
+   *    1. Homepage + subpages ingest
+   *    2. AI extraction from page content
+   *    3. AI gap-fill for fields still empty
+   *    4. Google search augmentation for inference fields
+   *    5. Industry-template fallback for anything still empty
+   */
   async function fillEmptyWithAi() {
     setError(null);
     const url = (brain.website_url || "").trim();
@@ -207,33 +216,73 @@ export function BrandBrainForm({ initial }: Props) {
     }
     setExtracting(true);
     try {
+      // PASS 1: Homepage + subpages
       const r = await ingestUrl(url);
       if (!r.ok) { setError(r.message); return; }
-      // Pull subpages too — much richer signal.
       let content = r.content;
       try {
         const sub = await ingestSubpages(r, undefined, 3);
         if (sub.pages.length) content = r.content + sub.extraContent;
       } catch {}
       const det = deterministicFillFromMetadata(r.metadata, r.url);
-      const prompt = buildBrandExtractionPrompt({
-        website_content: content,
-        description: `Brand at ${url}`,
-        audience_notes: "",
-        reviews: "",
-        metadata: r.metadata,
-        prefilled: { business_name: brain.business_name, industry: brain.industry, niche: brain.niche, usp: brain.usp },
-      });
+
+      // PASS 2: AI extraction from page content
       const res = await llmCall({
-        messages: [{ role: "user", content: prompt }],
+        messages: [{ role: "user", content: buildBrandExtractionPrompt({
+          website_content: content,
+          description: `Brand at ${url}`,
+          audience_notes: "",
+          reviews: "",
+          metadata: r.metadata,
+          prefilled: { business_name: brain.business_name, industry: brain.industry, niche: brain.niche, usp: brain.usp },
+        }) }],
         maxTokens: 3000,
         temperature: 0.7,
       });
-      const cost = estimateCostUsd(res.providerId, res.modelId, res.usage);
-      addUsage(cost, res.usage?.input_tokens ?? 0, res.usage?.output_tokens ?? 0);
+      addUsage(estimateCostUsd(res.providerId, res.modelId, res.usage), res.usage?.input_tokens ?? 0, res.usage?.output_tokens ?? 0);
       window.dispatchEvent(new Event("ados:usage"));
-      const parsed = tryParseJson<Partial<BrandBrain>>(res.text) ?? {};
-      setBrain((b) => mergeFillEmpty(b, parsed, { url, deterministic: det }));
+      const parsed: any = tryParseJson<any>(res.text) ?? {};
+
+      // PASS 3: Google search augmentation. ALWAYS runs in this fill-empty flow.
+      const searchableName = brain.business_name || parsed.business_name || det.business_name;
+      if (searchableName && searchableName.length > 2) {
+        const industryHint = (brain.industry || parsed.industry || det.industry || "").split(/[|·,]/)[0].trim();
+        const baseQuery = industryHint ? `${searchableName} ${industryHint} reviews competitors customers` : `${searchableName} reviews competitors`;
+        try {
+          const searchRes = await ingestUrl(`https://s.jina.ai/${encodeURIComponent(baseQuery)}`);
+          if (searchRes.ok && searchRes.content && searchRes.content.length > 500) {
+            const augRes = await llmCall({
+              messages: [{ role: "user", content: buildSearchAugmentedPrompt({
+                business_name: searchableName,
+                industry: brain.industry || parsed.industry || det.industry,
+                niche: brain.niche || parsed.niche || det.niche,
+                usp: brain.usp || parsed.usp || det.usp,
+                search_content: searchRes.content,
+                missing_fields: ["tone", "audience_who", "audience_pain_points", "audience_desires", "key_benefits", "competitors", "objections", "objection_handling", "words_to_use", "content_pillars"],
+              }) }],
+              maxTokens: 2500,
+              temperature: 0.7,
+            });
+            addUsage(estimateCostUsd(augRes.providerId, augRes.modelId, augRes.usage), augRes.usage?.input_tokens ?? 0, augRes.usage?.output_tokens ?? 0);
+            window.dispatchEvent(new Event("ados:usage"));
+            const augParsed: any = tryParseJson<any>(augRes.text) ?? {};
+            // Merge augParsed into parsed for any field parsed left empty
+            for (const k of Object.keys(augParsed)) {
+              const cur = parsed[k];
+              if (cur == null || (Array.isArray(cur) && !cur.length) || (typeof cur === "string" && !cur.trim())) {
+                parsed[k] = augParsed[k];
+              }
+            }
+          }
+        } catch {}
+      }
+
+      // PASS 4: Merge into brain (fill-empty only) → industry fallback for anything still empty
+      setBrain((b) => {
+        const merged = mergeFillEmpty(b, parsed as Partial<BrandBrain>, { url, deterministic: det });
+        const { brain: withFallback } = applyIndustryFallback(merged);
+        return withFallback;
+      });
     } catch (e: any) {
       setError(e?.message ?? "Fill failed");
     } finally {

lib/industry-fallback.ts

@@ -1,6 +1,34 @@
 import { INDUSTRY_TEMPLATES } from "./industry-templates";
 import type { BrandBrain } from "./brand-brain";
 
+/** Last-resort defaults applied when no industry template keyword matches AND
+ *  the AI passes left fields empty. Values are deliberately generic but
+ *  non-empty so the form never ships with blank inference fields.
+ *  User can edit anything before saving. */
+const GENERIC_FALLBACK: Partial<BrandBrain> = {
+  tone: "Confident, clear, customer-focused",
+  personality_traits: ["Helpful", "Knowledgeable", "Direct"],
+  writing_style: "Short, plain-language sentences. Lead with the customer benefit.",
+  audience_who: "Decision-makers researching options in this category",
+  audience_pain_points: ["Not enough time to evaluate every option", "Hard to tell real differentiators from marketing fluff", "Worried about wasting budget"],
+  audience_desires: ["A clear answer that fits their situation", "Confidence in the choice", "Results, not just promises"],
+  audience_demographics: "Adult consumers / professionals (25-55), English-speaking, online-savvy",
+  key_benefits: ["Solves the core problem in this category", "Saves time vs alternatives", "Backed by people who actually know what they're doing"],
+  key_messages: ["We focus on what actually matters for your outcome", "Built for real-world use, not marketing demos"],
+  words_to_use: ["actually", "specifically", "what matters", "real results", "in practice"],
+  words_to_avoid: ["world-class", "best-in-class", "synergy", "leverage", "transform"],
+  competitors: ["Larger incumbents", "DIY / free alternatives", "Other specialists in this category"],
+  differentiators: ["Personal attention vs. assembly-line operations", "Real outcomes over impressive promises"],
+  price_positioning: "Mid-market — fair value for what you get",
+  objections: ["How long does this take?", "What if it doesn't work for my situation?", "What does it actually cost?"],
+  objection_handling: [
+    "Most customers see results within the first cycle — specific timelines depend on inputs you provide upfront.",
+    "We start with discovery so we can confirm fit before any commitment.",
+    "Pricing is transparent and scoped to what you actually need — we'll quote before work starts.",
+  ],
+  content_pillars: ["Educational deep-dives", "Customer outcomes + case studies", "Behind-the-scenes / how we work", "Industry commentary"],
+};
+
 /**
  * After the AI extraction passes finish, some inference fields commonly stay
  * empty when the model is light (Gemini Flash, free-tier Llama). Rather than
@@ -58,13 +86,23 @@ export function pickClosestTemplate(industry: string, niche: string): string | n
  */
 export function applyIndustryFallback(brain: BrandBrain): { brain: BrandBrain; filled: string[]; templateSlug: string | null } {
   const slug = pickClosestTemplate(brain.industry || "", brain.niche || "");
-  if (!slug) return { brain, filled: [], templateSlug: null };
-
-  const template = INDUSTRY_TEMPLATES.find((t) => t.slug === slug);
-  if (!template) return { brain, filled: [], templateSlug: null };
+  let filled: Partial<BrandBrain>;
+  let usedSlug: string | null = slug;
 
-  // Get the template's filled values by applying it with no overrides.
-  const filled = template.apply({ business_name: brain.business_name || "Your Brand" });
+  if (slug) {
+    const template = INDUSTRY_TEMPLATES.find((t) => t.slug === slug);
+    if (template) {
+      filled = template.apply({ business_name: brain.business_name || "Your Brand" });
+    } else {
+      filled = GENERIC_FALLBACK;
+      usedSlug = "generic";
+    }
+  } else {
+    // No keyword match — use generic defaults so the user is never left with
+    // a blank form. Better a generic non-empty starting point than empty.
+    filled = GENERIC_FALLBACK;
+    usedSlug = "generic";
+  }
   const out: any = { ...brain };
   const touched: string[] = [];
 
@@ -92,5 +130,5 @@ export function applyIndustryFallback(brain: BrandBrain): { brain: BrandBrain; f
     }
   }
 
-  return { brain: out as BrandBrain, filled: touched, templateSlug: slug };
+  return { brain: out as BrandBrain, filled: touched, templateSlug: usedSlug };
 }