fix: preserve dual-schema-source guard through layer translation

Copilot review (PR #288): when a single config layer sets both a
non-empty `schema:` and a non-empty `inline-schema:`,
extractSchemaSourceFromSettings returned at the `schema` arm and
TranslateLayerSettings then stripped both keys, silently dropping
the inline source. The rule's rejectDualSchemaSettings guard in
ApplySettings was bypassed because translation removed the keys
before ApplySettings ran, and top-level cfg.Rules / overrides /
convention presets are not covered by validateKindSchemaSources.

TranslateLayerSettings now detects a dual-source layer
(hasDualSchemaSource, mirroring rejectDualSchemaSettings'
non-empty semantics) and passes the layer through untouched, so
the keys survive deep-merge and the existing guard still surfaces
the original "cannot set both" config error. Cross-layer
composition is unaffected — the check only fires when one map
carries both. Added regression tests; new code is 100% line and
branch covered.

Author: claude

internal/rules/requiredstructure/inline_schema_test.go

@@ -456,6 +456,48 @@ func TestApplySettings_RejectsBothSources(t *testing.T) {
 	assert.Contains(t, err.Error(), "cannot set both")
 }
 
+// TestTranslateLayerSettings_DualSourcePreservesGuard regresses
+// the Copilot review on PR #288: when one config layer sets both
+// a non-empty `schema:` and a non-empty `inline-schema:`, the
+// translator must NOT strip the keys (which would silently drop
+// the inline source). It passes the layer through unchanged so
+// the keys survive deep-merge and ApplySettings' dual-source
+// guard still surfaces the original config error.
+func TestTranslateLayerSettings_DualSourcePreservesGuard(t *testing.T) {
+	r := &Rule{}
+	dual := map[string]any{
+		"schema": "schemas/rfc.md",
+		"inline-schema": map[string]any{
+			"sections": []any{map[string]any{"heading": "X"}},
+		},
+	}
+	out := r.TranslateLayerSettings(dual)
+	// Untouched: both legacy keys survive, no schema-sources added.
+	assert.Equal(t, "schemas/rfc.md", out["schema"],
+		"dual-source layer must pass through with `schema` intact")
+	assert.Contains(t, out, "inline-schema",
+		"dual-source layer must pass through with `inline-schema` intact")
+	assert.NotContains(t, out, "schema-sources",
+		"dual-source layer must not be translated to schema-sources")
+	// The surviving keys still trip the rule's guard.
+	err := r.ApplySettings(out)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "cannot set both")
+}
+
+// TestTranslateLayerSettings_SingleSourcesStillTranslate confirms
+// the dual-source guard does not regress the normal single-source
+// translation (only one of the two keys, non-empty).
+func TestTranslateLayerSettings_SingleSourcesStillTranslate(t *testing.T) {
+	r := &Rule{}
+	out := r.TranslateLayerSettings(map[string]any{"schema": "x.md"})
+	srcs, ok := out["schema-sources"].([]any)
+	require.True(t, ok)
+	require.Len(t, srcs, 1)
+	assert.Equal(t, "x.md", srcs[0].(map[string]any)["file"])
+	assert.NotContains(t, out, "schema")
+}
+
 func TestApplySettings_AllowsEmptySchemaWithInline(t *testing.T) {
 	// An empty `schema:""` next to a real `inline-schema` is the
 	// merge-clears-prior-state state; the rule must still accept it.

internal/rules/requiredstructure/rule.go

@@ -347,6 +347,16 @@ func (r *Rule) SettingMergeMode(key string) rule.MergeMode {
 // input map is treated as read-only; a new map is returned only
 // when a legacy key is present.
 func (r *Rule) TranslateLayerSettings(settings map[string]any) map[string]any {
+	// A single layer that sets BOTH a non-empty `schema:` and a
+	// non-empty `inline-schema:` is a config error. Pass the layer
+	// through untouched so the keys survive deep-merge and the
+	// rule's own rejectDualSchemaSettings (run from ApplySettings)
+	// still surfaces the original error — stripping them here would
+	// silently drop the inline source. Cross-layer composition is
+	// unaffected: this only fires when one map carries both.
+	if hasDualSchemaSource(settings) {
+		return settings
+	}
 	source, hadKey := extractSchemaSourceFromSettings(settings)
 	if !hadKey {
 		return settings
@@ -361,6 +371,17 @@ func (r *Rule) TranslateLayerSettings(settings map[string]any) map[string]any {
 	return out
 }
 
+// hasDualSchemaSource reports whether one settings map sets both a
+// non-empty `schema:` path and a non-empty `inline-schema:` map.
+// It mirrors rejectDualSchemaSettings' non-empty semantics so the
+// translator and the rule's guard agree on what counts as a
+// dual-source layer.
+func hasDualSchemaSource(s map[string]any) bool {
+	path, _ := s["schema"].(string)
+	inline, _ := s["inline-schema"].(map[string]any)
+	return path != "" && len(inline) > 0
+}
+
 // extractSchemaSourceFromSettings inspects a settings map for a
 // schema-source declaration. It returns (source, true) when either
 // legacy key is present — even if the value is empty / no-op — so