Store category prompts as EXACT split legacy text, no boilerplate

The per-category prompt editor showed English machine boilerplate
("Role: description. Build JSON …", schema intro, {{var}} context lines)
because seed/sync baked the render framing into categories.prompt. Now the
stored overlay is exactly the legacy wp_product_categories.sql content,
split into the three sections a user would type themselves:

  --- Title ---        Slovenian naming formula
  --- Description ---  legacy <H2>/<p>/<ul> body structure
  --- Meta ---         legacy metaDescription instruction

Schema, role framing, and Name/Description/Category/Attrs product context
stay render-time only (system template + ensureCategoryEnhanceUserContext),
where they already existed.

- SplitLegacyCombinedEnhancePrompt: non-legacy input now returns "" —
  categories without seed/legacy content get their override CLEARED
  (company default) instead of being stuffed with the canonical template
  (e.g. parent categories like "Bela tehnika" absent from the SQL).
- CategoryEnhancePromptNeedsRepair flags stored boilerplate ("parsed as
  JSON", "Build JSON", retired Attributes section) so Sync rewrites old
  data to the clean shape; repair supports clearing (prompt = '{}').
- seed-a1 apply-category-prompts skips instead of writing template text.
- Web editor compose stores only the user's section text: empty sections
  keep bare markers, default bodies and the default preamble are never
  persisted (DEFAULT_SECTION_BODIES removed).
- Verified locally: apply rewrote 238 A1+Demo categories (216 exact
  splits, 22 cleared), zero boilerplate matches in DB, idempotent re-run
  (would_update=0).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

apps/api/cmd/seed-a1/category_prompts.go

@@ -188,7 +188,8 @@ func applyCategoryPrompts(ctx context.Context, pg *pgxpool.Pool, companyID uuid.
 	byNorm := make(map[string]string, len(file.Entries))
 	byUnique := make(map[string]string, len(file.Entries))
 	// Overlay: split each legacy combined Name+Description prompt into role-sectioned
-	// enhance USER text (Title / Description / Meta / Attributes). Unique title /
+	// enhance USER text (Title / Description / Meta) holding exactly the legacy
+	// per-category text — no schema/role boilerplate. Unique title /
 	// description / meta formulas stay in title_template / description_template.
 	// Stored under "sl" + "*" so prompt->>'sl' and LangPromptAny both resolve;
 	// language stays via {{language}}.
@@ -207,10 +208,13 @@ func applyCategoryPrompts(ctx context.Context, pg *pgxpool.Pool, companyID uuid.
 		}
 		if aiprompts.IsLegacyCombinedEnhancePrompt(raw) {
 			canonical = prepareCategoryPrompt(aiprompts.SplitLegacyCombinedEnhancePrompt(raw))
-		} else if aiprompts.CategoryEnhanceHasRoleSections(raw) {
+		} else if aiprompts.CategoryEnhanceHasRoleSections(raw) && !aiprompts.CategoryEnhancePromptNeedsRepair(raw) {
 			canonical = prepareCategoryPrompt(raw)
 		} else {
-			canonical = prepareCategoryPrompt(aiprompts.CategoryEnhanceUserTemplate)
+			// No usable per-category content — never store template boilerplate;
+			// the category keeps the company default.
+			out.Skipped++
+			continue
 		}
 		if canonical == "" {
 			out.Skipped++

apps/api/internal/aiprompts/kinds.go

@@ -84,12 +84,12 @@ Category: {{category}}
 Attrs: {{attrs}}`
 
 // CategoryEnhancePromptNeedsRepair reports whether a stored categories.prompt value
-// should be rewritten into role-sectioned enhance overlay form. Empty prompts are
-// left alone. Canonical CategoryEnhanceUserTemplate and per-category overlays that
-// already carry Title/Description/Meta markers are OK — equality with the shared
-// template is not required (legacy splits keep Slovenian rules). Prompts still
-// carrying a retired "--- Attributes ---" role section are rewritten so attribute
-// prompting stays out of category prompts.
+// should be rewritten into clean role-sectioned overlay form (or cleared). Empty
+// prompts are left alone. A clean overlay carries Title/Description/Meta markers
+// with ONLY the category's own instruction text — schema/role machine boilerplate
+// (old seed versions stored the canonical template text, "Build JSON …" role
+// instructions, and a retired "--- Attributes ---" section) marks a prompt for
+// repair so the prompt editor shows exactly the per-category rules.
 func CategoryEnhancePromptNeedsRepair(prompt string) bool {
 	p := strings.TrimSpace(prompt)
 	if p == "" {
@@ -101,7 +101,12 @@ func CategoryEnhancePromptNeedsRepair(prompt string) bool {
 	if !CategoryEnhanceHasRoleSections(p) {
 		return true
 	}
-	return strings.Contains(strings.ToLower(p), strings.ToLower(SectionAttributesStart))
+	lower := strings.ToLower(p)
+	if strings.Contains(lower, strings.ToLower(SectionAttributesStart)) {
+		return true
+	}
+	return strings.Contains(lower, "your reply is parsed as json") ||
+		strings.Contains(lower, `build json "`)
 }
 
 // BuiltInDefaults match the previous hardcoded system prompts, with structured user templates.

apps/api/internal/aiprompts/kinds_test.go

@@ -43,17 +43,16 @@ func TestCategoryEnhancePromptNeedsRepair(t *testing.T) {
 	if CategoryEnhancePromptNeedsRepair("") {
 		t.Fatal("empty should not need repair")
 	}
-	if CategoryEnhancePromptNeedsRepair(CategoryEnhanceUserTemplate) {
-		t.Fatal("canonical template should be idempotent")
-	}
-	if CategoryEnhancePromptNeedsRepair("  " + CategoryEnhanceUserTemplate + "\n") {
-		t.Fatal("whitespace-trimmed canonical should be idempotent")
+	// A STORED copy of the built-in template is boilerplate pollution — repair
+	// clears it so the category falls back to the company default.
+	if !CategoryEnhancePromptNeedsRepair(CategoryEnhanceUserTemplate) {
+		t.Fatal("stored canonical template text should need repair (cleared to default)")
 	}
 	legacy := `Ustvari nov opis\n<H2>foo</H2>\nAttrs missing`
 	if !CategoryEnhancePromptNeedsRepair(legacy) {
 		t.Fatal("legacy HTML prompt should need repair")
 	}
-	// Per-category sectioned overlay (Slovenian rules) must not force re-repair.
+	// Per-category sectioned overlay (pure Slovenian rules) must not force re-repair.
 	split := SplitLegacyCombinedEnhancePrompt(`GPT predloga:
 <name>{Napiši tip izdelka}</name>
 <metaDescription>{140 znakov}</metaDescription>
@@ -61,6 +60,9 @@ func TestCategoryEnhancePromptNeedsRepair(t *testing.T) {
 	if CategoryEnhancePromptNeedsRepair(split) {
 		t.Fatal("sectioned split overlay should be idempotent")
 	}
+	if CategoryEnhancePromptNeedsRepair("  " + split + "\n") {
+		t.Fatal("whitespace-trimmed split overlay should be idempotent")
+	}
 }
 
 func TestBuiltInProductEnhanceUsesSharedUserTemplate(t *testing.T) {

apps/api/internal/aiprompts/legacy_split.go

@@ -74,61 +74,39 @@ func ParseLegacyCombinedEnhancePrompt(prompt string) LegacyEnhanceParts {
 }
 
 // SplitLegacyCombinedEnhancePrompt rewrites a legacy combined name+description(+meta)
-// prompt into CategoryEnhanceUserTemplate role sections, preserving Slovenian
-// naming / HTML / meta intent as category-specific rules under Title / Description / Meta.
-// Non-legacy input returns CategoryEnhanceUserTemplate (canonical shared overlay).
+// prompt into role sections carrying ONLY the original per-category text — the
+// Slovenian naming formula under Title, the HTML body structure under Description,
+// the SEO instruction under Meta. No schema/role boilerplate is stored: JSON
+// schema, role framing, and {{name}}/{{description}}/{{category}}/{{attrs}}
+// product context are all supplied at render time (system template +
+// processing.ensureCategoryEnhanceUserContext). Non-legacy input returns "" —
+// callers leave the category without an override (company default applies).
 func SplitLegacyCombinedEnhancePrompt(prompt string) string {
 	parts := ParseLegacyCombinedEnhancePrompt(prompt)
 	if !parts.WasLegacy {
-		return strings.TrimSpace(CategoryEnhanceUserTemplate)
+		return ""
 	}
 	return BuildCategoryEnhanceOverlay(parts)
 }
 
 // BuildCategoryEnhanceOverlay composes a role-sectioned enhance USER overlay from
-// extracted legacy parts (or empty parts → canonical template text with no extra rules).
+// extracted legacy parts — the stored text is exactly the split legacy content,
+// matching what a user would type into the Title/Description/Meta prompt areas.
 func BuildCategoryEnhanceOverlay(parts LegacyEnhanceParts) string {
 	var b strings.Builder
-	b.WriteString(`Your reply is parsed as JSON {"name":"string","description":"string","meta_title":"string","meta_description":"string","attrs":{}} only (system schema). Write all string fields in {{language}} (do not hardcode a language).`)
-	b.WriteString("\n\n")
-
-	b.WriteString(SectionTitleStart)
-	b.WriteByte('\n')
-	b.WriteString(TitleRoleInstruction)
-	b.WriteByte('\n')
-	if rules := strings.TrimSpace(parts.TitleRules); rules != "" {
-		b.WriteString("Category naming rules (preserve intent): ")
-		b.WriteString(rules)
+	section := func(start, end, body string) {
+		b.WriteString(start)
 		b.WriteByte('\n')
+		if body = strings.TrimSpace(body); body != "" {
+			b.WriteString(body)
+			b.WriteByte('\n')
+		}
+		b.WriteString(end)
+		b.WriteString("\n\n")
 	}
-	b.WriteString("Name: {{name}}\n")
-	b.WriteString(SectionTitleEnd)
-	b.WriteString("\n\n")
-
-	b.WriteString(SectionDescriptionStart)
-	b.WriteString("\nRole: description. Build JSON \"description\": product body HTML only (not SEO meta). When a Description formula follows, emit ONE HTML string covering each section in order (tags matching type: h1/h2/h3/h4, p, ul); otherwise prefer 1-3 factual paragraphs as ONE string with limited HTML (<h2><p><ul><li>) — do NOT emit a competing full HTML document or wrap the whole reply in <name>/<metaDescription> tags.\n")
-	if rules := strings.TrimSpace(parts.DescriptionRules); rules != "" {
-		b.WriteString("Category HTML structure (preserve intent; emit as ONE description HTML string, not tagged name/meta blocks):\n")
-		b.WriteString(rules)
-		b.WriteByte('\n')
-	}
-	b.WriteString("Description: {{description}}\n")
-	b.WriteString(SectionDescriptionEnd)
-	b.WriteString("\n\n")
-
-	b.WriteString(SectionMetaStart)
-	b.WriteString("\nRole: meta. Build JSON \"meta_title\" and \"meta_description\" as plain SEO text (never HTML). meta_title: 50-60 chars; meta_description: 120-155 chars; follow any SEO meta formula that follows; never copy the full description HTML into meta_description.\n")
-	if rules := strings.TrimSpace(parts.MetaRules); rules != "" {
-		b.WriteString("Category SEO rules (preserve intent; plain text only): ")
-		b.WriteString(rules)
-		b.WriteByte('\n')
-	}
-	b.WriteString(SectionMetaEnd)
-	b.WriteString("\n\n")
-
-	b.WriteString("Product context:\n")
-	b.WriteString("Category: {{category}}\n")
-	b.WriteString("Attrs: {{attrs}}")
+	section(SectionTitleStart, SectionTitleEnd, parts.TitleRules)
+	section(SectionDescriptionStart, SectionDescriptionEnd, parts.DescriptionRules)
+	section(SectionMetaStart, SectionMetaEnd, parts.MetaRules)
 	return strings.TrimSpace(b.String())
 }
 

apps/api/internal/aiprompts/legacy_split_test.go

@@ -44,19 +44,25 @@ GPT predloga:
 	if !strings.Contains(got, "Tehnične specifikacije") && !strings.Contains(got, "tehničnih specifikacij") {
 		t.Fatal("description section must preserve HTML body intent")
 	}
-	if !strings.Contains(got, "{{attrs}}") || !strings.Contains(got, "{{language}}") {
-		t.Fatal("overlay must keep {{attrs}} and {{language}}")
+	// The stored overlay is EXACTLY the split legacy text — no schema/role
+	// boilerplate, no {{var}} placeholders (product context is render-time).
+	lower := strings.ToLower(got)
+	for _, junk := range []string{"your reply is parsed as json", "role: title", "role: description", "role: meta", "{{attrs}}", "{{name}}", "{{language}}", "product context"} {
+		if strings.Contains(lower, junk) {
+			t.Fatalf("overlay must not carry boilerplate %q:\n%s", junk, got)
+		}
 	}
 	if strings.Contains(got, "OPIS IZDELKA") || strings.Contains(got, "STARO IME IZDELKA") {
 		t.Fatal("legacy placeholders must be modernized")
 	}
 }
 
-func TestSplitLegacyNonLegacyFallsBackToTemplate(t *testing.T) {
+func TestSplitLegacyNonLegacyReturnsEmpty(t *testing.T) {
 	t.Parallel()
-	got := SplitLegacyCombinedEnhancePrompt("short retail overlay")
-	if strings.TrimSpace(got) != strings.TrimSpace(CategoryEnhanceUserTemplate) {
-		t.Fatalf("non-legacy should fall back to canonical template")
+	// Non-legacy input has no per-category content to preserve — callers must
+	// leave the category on the company default instead of storing boilerplate.
+	if got := SplitLegacyCombinedEnhancePrompt("short retail overlay"); got != "" {
+		t.Fatalf("non-legacy should return empty, got %q", got)
 	}
 }
 

apps/api/internal/aiprompts/roles_test.go

@@ -25,8 +25,10 @@ func TestCategoryEnhanceHasRoleSections(t *testing.T) {
 	if !CategoryEnhancePromptNeedsRepair(old) {
 		t.Fatal("old attributes-bearing prompt must need repair (attributes section retired)")
 	}
-	if CategoryEnhancePromptNeedsRepair(CategoryEnhanceUserTemplate) {
-		t.Fatal("canonical template must not need repair")
+	// The built-in template is render-time only; a STORED copy is boilerplate
+	// pollution and must be repaired (cleared to company default).
+	if !CategoryEnhancePromptNeedsRepair(CategoryEnhanceUserTemplate) {
+		t.Fatal("stored canonical template text must need repair")
 	}
 }
 

apps/api/internal/aiprompts/title_formula_test.go

@@ -86,12 +86,17 @@ func TestTitleRoleInstructionNeverBrandOnly(t *testing.T) {
 	if !strings.Contains(CategoryEnhanceUserTemplate, TitleRoleInstruction) {
 		t.Fatal("CategoryEnhanceUserTemplate must embed TitleRoleInstruction")
 	}
+	// Split overlays carry ONLY the legacy per-category text; the never-brand-only
+	// rule lives in the render-time role framing, not the stored prompt.
 	split := SplitLegacyCombinedEnhancePrompt(`GPT predloga:
 <name>{Napiši tip izdelka, znamka, poln model}</name>
 <metaDescription>{140 znakov}</metaDescription>
 <H2>{benefit}</H2>`)
-	if !strings.Contains(split, "never brand-only") {
-		t.Fatalf("split Title section missing never brand-only: %s", split)
+	if strings.Contains(split, "never brand-only") {
+		t.Fatalf("split overlay must not embed role boilerplate: %s", split)
+	}
+	if !strings.Contains(split, "Napiši tip izdelka, znamka, poln model") {
+		t.Fatalf("split Title section must keep the legacy naming text: %s", split)
 	}
 }
 

apps/api/internal/catalog/fix_catalog_test.go

@@ -15,13 +15,15 @@ func TestCategoryEnhanceTemplateHasAttrs(t *testing.T) {
 		t.Fatalf("template missing {{attrs}}: %q", tpl)
 	}
 	if !aiprompts.CategoryEnhanceHasRoleSections(tpl) {
-		t.Fatal("repaired template must include title/description/meta/attributes sections")
+		t.Fatal("built-in template must include title/description/meta sections")
 	}
 	if !aiprompts.CategoryEnhancePromptNeedsRepair("legacy HTML prompt without attrs") {
 		t.Fatal("expected legacy prompt to need repair")
 	}
-	if aiprompts.CategoryEnhancePromptNeedsRepair(tpl) {
-		t.Fatal("canonical template should not need repair")
+	// The built-in template is render-time only; STORED copies of it are
+	// boilerplate pollution and must be repaired (cleared).
+	if !aiprompts.CategoryEnhancePromptNeedsRepair(tpl) {
+		t.Fatal("stored template text should need repair")
 	}
 }
 
@@ -32,21 +34,6 @@ func TestPlatformDemoNameConstant(t *testing.T) {
 	}
 }
 
-func TestRepairedCategoryEnhancePromptMapMatchesA1Demo(t *testing.T) {
-	t.Parallel()
-	want, err := repairedCategoryEnhancePromptMap()
-	if err != nil {
-		t.Fatal(err)
-	}
-	tpl := strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate)
-	if want["sl"] != tpl || want[company.LangPromptAny] != tpl {
-		t.Fatalf("want sl+* template, got %#v", want)
-	}
-	if !strings.Contains(tpl, "{{attrs}}") {
-		t.Fatal("template must include {{attrs}}")
-	}
-}
-
 func TestCategoryEnhancePromptMapOKAcceptsSplitOverlay(t *testing.T) {
 	t.Parallel()
 	legacy := `GPT predloga:

apps/api/internal/catalog/prompt_repair.go

@@ -62,10 +62,12 @@ type RepairA1DemoOptions struct {
 
 // RepairA1DemoCategoryEnhancePrompts replaces non-sectioned / legacy combined
 // categories.prompt values for A1 Slovenija + Platform Demo with role-sectioned
-// overlays (Title / Description / Meta). Prefers wp_product_categories.sql
-// (SEED_A1_WP_CATEGORIES / scripts/seed) as source of truth, then a1-category-prompts.json,
-// splitting combined Name+Description prompts so naming rules land under Title and
-// HTML body under Description; otherwise fall back to CategoryEnhanceUserTemplate.
+// overlays (Title / Description / Meta) carrying exactly the split legacy text.
+// Prefers wp_product_categories.sql (SEED_A1_WP_CATEGORIES / scripts/seed) as
+// source of truth, then a1-category-prompts.json, splitting combined
+// Name+Description prompts so naming rules land under Title and HTML body under
+// Description; categories with no seed/legacy content have their override
+// cleared (company default) — template boilerplate is never stored.
 //
 // Also repairs empty or brand-only title_template and empty description_template
 // from legacy <name> / HTML / meta blocks so enhance uses real A1 formulas.
@@ -337,19 +339,6 @@ func foldSlovenePromptRune(r rune) rune {
 	}
 }
 
-// repairedCategoryEnhancePromptMap is the shared fallback overlay (no per-category
-// Slovenian rules): "sl" + LangPromptAny ("*").
-func repairedCategoryEnhancePromptMap() (company.LangPromptMap, error) {
-	tpl := strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate)
-	if tpl == "" {
-		return nil, fmt.Errorf("CategoryEnhanceUserTemplate is empty")
-	}
-	return company.LangPromptMap{
-		"sl":                  tpl,
-		company.LangPromptAny: tpl,
-	}, nil
-}
-
 func categoryEnhancePromptValueOK(p string) bool {
 	p = strings.TrimSpace(p)
 	if p == "" {
@@ -406,6 +395,10 @@ func resolveRepairedEnhancePrompt(current company.LangPromptMap, seedLegacy stri
 	return prompt
 }
 
+// computeRepairedEnhancePrompt returns the clean role-sectioned overlay for a
+// category — exactly the split per-category text. "" means the override should
+// be CLEARED (no legacy/seed content to preserve → company default applies);
+// fallback reports that clear case.
 func computeRepairedEnhancePrompt(current company.LangPromptMap, seedLegacy string, preferSeed bool) (prompt string, fromSeed, fromLegacy, fallback bool) {
 	trySeed := func(raw string) (string, bool, bool) {
 		raw = strings.TrimSpace(raw)
@@ -415,10 +408,10 @@ func computeRepairedEnhancePrompt(current company.LangPromptMap, seedLegacy stri
 		if aiprompts.IsLegacyCombinedEnhancePrompt(raw) {
 			return aiprompts.SplitLegacyCombinedEnhancePrompt(raw), true, false
 		}
-		if aiprompts.CategoryEnhanceHasRoleSections(raw) {
+		if aiprompts.CategoryEnhanceHasRoleSections(raw) && !aiprompts.CategoryEnhancePromptNeedsRepair(raw) {
 			return security.SanitizePrompt(raw, MaxCategoryPromptRunes), false, false
 		}
-		return strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate), false, true
+		return "", false, true
 	}
 
 	if preferSeed && seedLegacy != "" {
@@ -439,7 +432,7 @@ func computeRepairedEnhancePrompt(current company.LangPromptMap, seedLegacy stri
 		p, leg, fb := trySeed(seedLegacy)
 		return p, true, leg, fb
 	}
-	return strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate), false, false, true
+	return "", false, false, true
 }
 
 func repairCompanyCategoryEnhancePrompts(
@@ -485,8 +478,9 @@ func repairCompanyCategoryEnhancePrompts(
 
 		seedLegacy := pickSeedPrompt(uniqueID, name, seedByNorm, seedByUID)
 		needPrompt := company.HasAnyPrompt(m) && !categoryEnhancePromptMapOK(m)
-		// Empty prompt → write sectioned overlay (seed split when available, else shared template).
-		if !company.HasAnyPrompt(m) {
+		// Empty prompt: only seed-matched categories get an overlay written;
+		// categories without seed content stay on the company default.
+		if !company.HasAnyPrompt(m) && seedLegacy != "" {
 			needPrompt = true
 		}
 
@@ -539,11 +533,14 @@ func repairCompanyCategoryEnhancePrompts(
 			continue
 		}
 
+		// clearPrompt: repair resolved to "no content" → drop the override so the
+		// category falls back to the company default (never store template boilerplate).
+		clearPrompt := false
 		if needPrompt && wantPrompt == "" {
 			wantPrompt = resolveRepairedEnhancePrompt(m, seedLegacy, forceFromSeed && seedLegacy != "", out)
 			wantPrompt = security.SanitizePrompt(wantPrompt, MaxCategoryPromptRunes)
 			if wantPrompt == "" {
-				return updatedHere, fmt.Errorf("repaired prompt empty category=%s", id)
+				clearPrompt = true
 			}
 		} else if needPrompt {
 			// Record seed/split stats for the prompt we already computed.
@@ -571,7 +568,18 @@ func repairCompanyCategoryEnhancePrompts(
 			continue
 		}
 
-		if needPrompt {
+		if needPrompt && clearPrompt {
+			ct, err := pool.Exec(ctx, `
+				UPDATE categories
+				SET prompt = '{}'::jsonb, updated_at = now()
+				WHERE id = $1 AND company_id = $2`, id, companyID)
+			if err != nil {
+				return updatedHere, fmt.Errorf("clear prompt category=%s: %w", id, err)
+			}
+			if ct.RowsAffected() == 0 {
+				return updatedHere, fmt.Errorf("category %s not updated (company mismatch?)", id)
+			}
+		} else if needPrompt {
 			want := company.LangPromptMap{
 				"sl":                  wantPrompt,
 				company.LangPromptAny: wantPrompt,

apps/api/internal/catalog/prompt_repair_test.go

@@ -8,33 +8,33 @@ import (
 	"github.com/descrybe/descrybe-v2/apps/api/internal/company"
 )
 
-func TestRepairedCategoryEnhancePromptMap(t *testing.T) {
+func TestCategoryEnhancePromptMapRepairStates(t *testing.T) {
 	t.Parallel()
-	want, err := repairedCategoryEnhancePromptMap()
-	if err != nil {
-		t.Fatal(err)
+	// Clean split overlay (pure legacy text) is OK under sl and *.
+	split := aiprompts.SplitLegacyCombinedEnhancePrompt(`GPT predloga:
+<name>{Napiši tip izdelka}</name>
+<metaDescription>{140 znakov}</metaDescription>
+<H2>{benefit}</H2>`)
+	if split == "" {
+		t.Fatal("expected split overlay")
 	}
-	tpl := strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate)
-	if want["sl"] != tpl {
-		t.Fatalf("want prompt->>'sl' = shared template")
+	if !categoryEnhancePromptMapOK(company.LangPromptMap{"sl": split, company.LangPromptAny: split}) {
+		t.Fatal("split overlay map should be OK")
 	}
-	if want[company.LangPromptAny] != tpl {
-		t.Fatalf("want * = shared template")
+	if !categoryEnhancePromptMapOK(company.LangPromptMap{"sl": split}) {
+		t.Fatal("sl-only split map should be OK (idempotent)")
 	}
-	if !categoryEnhancePromptMapOK(want) {
-		t.Fatal("canonical map should be OK")
+	if !categoryEnhancePromptMapOK(company.LangPromptMap{company.LangPromptAny: split}) {
+		t.Fatal("*-only split map should be OK (idempotent)")
 	}
 	legacy := company.LangPromptMap{"sl": "<H2>legacy HTML marketing</H2>"}
 	if categoryEnhancePromptMapOK(legacy) {
 		t.Fatal("legacy HTML must need repair")
 	}
-	slOnly := company.LangPromptMap{"sl": tpl}
-	if !categoryEnhancePromptMapOK(slOnly) {
-		t.Fatal("sl-only repaired map should be OK (idempotent)")
-	}
-	starOnly := company.LangPromptMap{company.LangPromptAny: tpl}
-	if !categoryEnhancePromptMapOK(starOnly) {
-		t.Fatal("*-only repaired map should be OK (idempotent)")
+	// Stored template boilerplate (old seed versions) must need repair → cleared.
+	tpl := strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate)
+	if categoryEnhancePromptMapOK(company.LangPromptMap{"sl": tpl, company.LangPromptAny: tpl}) {
+		t.Fatal("stored template boilerplate must need repair")
 	}
 }
 
@@ -54,6 +54,28 @@ func TestRepairTargetsUseSharedTemplate(t *testing.T) {
 	}
 }
 
+func TestComputeRepairedEnhancePromptClears(t *testing.T) {
+	t.Parallel()
+	// No seed + no legacy content → clear (fallback), never template boilerplate.
+	prompt, fromSeed, fromLegacy, fallback := computeRepairedEnhancePrompt(
+		company.LangPromptMap{"sl": strings.TrimSpace(aiprompts.CategoryEnhanceUserTemplate)}, "", false)
+	if prompt != "" || fromSeed || fromLegacy || !fallback {
+		t.Fatalf("want clear fallback, got prompt=%q seed=%v legacy=%v fallback=%v", prompt, fromSeed, fromLegacy, fallback)
+	}
+	// Seed legacy → split overlay with the exact Slovenian text.
+	seed := `GPT predloga:
+<name>{Napiši tip izdelka}</name>
+<metaDescription>{140 znakov}</metaDescription>
+<H2>{benefit}</H2>`
+	prompt, fromSeed, fromLegacy, fallback = computeRepairedEnhancePrompt(nil, seed, true)
+	if prompt == "" || !fromSeed || !fromLegacy || fallback {
+		t.Fatalf("want seed split, got prompt=%q seed=%v legacy=%v fallback=%v", prompt, fromSeed, fromLegacy, fallback)
+	}
+	if !strings.Contains(prompt, "140 znakov") || strings.Contains(strings.ToLower(prompt), "build json") {
+		t.Fatalf("split must keep legacy text without boilerplate: %q", prompt)
+	}
+}
+
 func TestLegacyTitleRulesFromSeedShape(t *testing.T) {
 	t.Parallel()
 	seed := `Ustvari nov opis