diff --git a/docs/REFERENCE.md b/docs/REFERENCE.md
index f8bbc089..0bc83763 100644
--- a/docs/REFERENCE.md
+++ b/docs/REFERENCE.md
@@ -129,12 +129,11 @@ Override score, severity, or enable/disable individual rules:
 | `missing-interaction-state` | -3 | missing-info |
 | `missing-prototype` | -3 | missing-info |
 
-**Minor (4 rules)** — naming issues with negligible impact (ΔV < 2%)
+**Minor (3 rules)** — naming issues with negligible impact (ΔV < 2%)
 
 | Rule ID | Default Score | Default Severity |
 |---------|--------------|-----------------|
 | `non-standard-naming` | -1 | suggestion |
-| `default-name` | -1 | suggestion |
 | `non-semantic-name` | -1 | suggestion |
 | `inconsistent-naming-convention` | -1 | suggestion |
 <!-- RULE_TABLE_END -->
diff --git a/src/cli/docs.ts b/src/cli/docs.ts
index 20855a0e..b18804b5 100644
--- a/src/cli/docs.ts
+++ b/src/cli/docs.ts
@@ -101,7 +101,7 @@ EXAMPLE
     "rules": {
       "no-auto-layout": { "score": -15, "severity": "blocking" },
       "raw-value": { "score": -5 },
-      "default-name": { "enabled": false }
+      "non-semantic-name": { "enabled": false }
     }
   }
 
diff --git a/src/core/contracts/rule.ts b/src/core/contracts/rule.ts
index c9bd4753..5cb211b2 100644
--- a/src/core/contracts/rule.ts
+++ b/src/core/contracts/rule.ts
@@ -111,7 +111,6 @@ export type RuleId =
   | "missing-prototype"
   // Minor — naming issues with negligible impact (ΔV < 2%)
   | "non-standard-naming"
-  | "default-name"
   | "non-semantic-name"
   | "inconsistent-naming-convention";
 
diff --git a/src/core/engine/rule-engine.test.ts b/src/core/engine/rule-engine.test.ts
index 35d4130d..0395c72e 100644
--- a/src/core/engine/rule-engine.test.ts
+++ b/src/core/engine/rule-engine.test.ts
@@ -206,14 +206,14 @@ describe("RuleEngine.analyze — rule filtering", () => {
     const file = makeFile({ document: doc });
 
     // Enable only default-name rule
-    const result = analyzeFile(file, { enabledRules: ["default-name"] });
+    const result = analyzeFile(file, { enabledRules: ["non-semantic-name"] });
 
     // Must have at least one issue to avoid vacuous pass
     expect(result.issues.length).toBeGreaterThan(0);
 
     // All issues should be from default-name only
     for (const issue of result.issues) {
-      expect(issue.violation.ruleId).toBe("default-name");
+      expect(issue.violation.ruleId).toBe("non-semantic-name");
     }
   });
 
@@ -229,13 +229,13 @@ describe("RuleEngine.analyze — rule filtering", () => {
     const file = makeFile({ document: doc });
 
     const resultAll = analyzeFile(file);
-    const resultDisabled = analyzeFile(file, { disabledRules: ["default-name"] });
+    const resultDisabled = analyzeFile(file, { disabledRules: ["non-semantic-name"] });
 
     const defaultNameAll = resultAll.issues.filter(
-      (i) => i.violation.ruleId === "default-name"
+      (i) => i.violation.ruleId === "non-semantic-name"
     );
     const defaultNameDisabled = resultDisabled.issues.filter(
-      (i) => i.violation.ruleId === "default-name"
+      (i) => i.violation.ruleId === "non-semantic-name"
     );
 
     // Baseline must have default-name issues to validate the filter
@@ -392,7 +392,7 @@ describe("RuleEngine.analyze — error resilience", () => {
     const file = makeFile({ document: doc });
 
     // Make an existing rule's check throw to verify error resilience
-    const defaultNameRule = ruleRegistry.get("default-name");
+    const defaultNameRule = ruleRegistry.get("non-semantic-name");
     expect(defaultNameRule).toBeDefined();
 
     const originalCheck = defaultNameRule!.check;
@@ -407,7 +407,7 @@ describe("RuleEngine.analyze — error resilience", () => {
       // failedRules should contain the failure details
       expect(result.failedRules.length).toBeGreaterThan(0);
 
-      const failure = result.failedRules.find((f) => f.ruleId === "default-name");
+      const failure = result.failedRules.find((f) => f.ruleId === "non-semantic-name");
       expect(failure).toBeDefined();
       expect(failure!.error).toBe("boom");
       expect(failure!.nodeName).toBeDefined();
diff --git a/src/core/engine/scoring.test.ts b/src/core/engine/scoring.test.ts
index 19cfa425..68e502ec 100644
--- a/src/core/engine/scoring.test.ts
+++ b/src/core/engine/scoring.test.ts
@@ -75,7 +75,7 @@ describe("calculateScores", () => {
       makeIssue({ ruleId: "no-auto-layout", category: "pixel-critical", severity: "blocking" }),
       makeIssue({ ruleId: "non-layout-container", category: "pixel-critical", severity: "risk" }),
       makeIssue({ ruleId: "raw-value", category: "token-management", severity: "missing-info" }),
-      makeIssue({ ruleId: "default-name", category: "minor", severity: "suggestion" }),
+      makeIssue({ ruleId: "non-semantic-name", category: "minor", severity: "suggestion" }),
     ];
     const scores = calculateScores(makeResult(issues));
 
@@ -90,7 +90,7 @@ describe("calculateScores", () => {
     const heavyIssue = makeIssue({ ruleId: "no-auto-layout", category: "pixel-critical", severity: "blocking", score: -10 });
     heavyIssue.calculatedScore = -15; // Simulate depthWeight effect
 
-    const lightIssue = makeIssue({ ruleId: "default-name", category: "minor", severity: "suggestion", score: -1 });
+    const lightIssue = makeIssue({ ruleId: "non-semantic-name", category: "minor", severity: "suggestion", score: -1 });
     lightIssue.calculatedScore = -1;
 
     const heavy = calculateScores(makeResult([heavyIssue], 100));
@@ -159,7 +159,7 @@ describe("calculateScores", () => {
     ], 100));
 
     const lightRule = calculateScores(makeResult([
-      makeIssue({ ruleId: "default-name", category: "minor", severity: "suggestion", score: -1 }),
+      makeIssue({ ruleId: "non-semantic-name", category: "minor", severity: "suggestion", score: -1 }),
     ], 100));
 
     expect(heavyRule.byCategory["pixel-critical"].diversityScore).toBeLessThan(
@@ -169,7 +169,7 @@ describe("calculateScores", () => {
 
   it("low-severity rules have minimal diversity impact (intentional)", () => {
     const lowSeverity = calculateScores(makeResult([
-      makeIssue({ ruleId: "default-name", category: "minor", severity: "suggestion", score: -1 }),
+      makeIssue({ ruleId: "non-semantic-name", category: "minor", severity: "suggestion", score: -1 }),
     ], 100));
 
     const highSeverity = calculateScores(makeResult([
@@ -304,7 +304,7 @@ describe("calculateGrade (via calculateScores)", () => {
       "code-quality": ["missing-component", "detached-instance", "variant-structure-mismatch", "deep-nesting"],
       "token-management": ["raw-value", "irregular-spacing"],
       "interaction": ["missing-interaction-state", "missing-prototype"],
-      "minor": ["non-standard-naming", "default-name", "non-semantic-name", "inconsistent-naming-convention"],
+      "minor": ["non-standard-naming", "non-semantic-name", "inconsistent-naming-convention"],
     };
 
     for (const cat of categories) {
diff --git a/src/core/engine/scoring.ts b/src/core/engine/scoring.ts
index c8a5dbed..0b0d2dd6 100644
--- a/src/core/engine/scoring.ts
+++ b/src/core/engine/scoring.ts
@@ -57,7 +57,7 @@ export type Grade = "S" | "A+" | "A" | "B+" | "B" | "C+" | "C" | "D" | "F";
  * the per-rule scores in rule-config.ts effectively unused.
  *
  * Now: `no-auto-layout` (score: -10, depthWeight: 1.5) at root contributes 15
- * to density, while `default-name` (score: -1, no depthWeight) contributes 1.
+ * to density, while `non-semantic-name` (score: -1, no depthWeight) contributes 1.
  * This makes calibration loop score adjustments flow through to user-facing scores.
  */
 
diff --git a/src/core/rules/component/detached-instance.test.ts b/src/core/rules/component/detached-instance.test.ts
index 4317eadd..ae9937a5 100644
--- a/src/core/rules/component/detached-instance.test.ts
+++ b/src/core/rules/component/detached-instance.test.ts
@@ -47,6 +47,26 @@ describe("detached-instance", () => {
     expect(detachedInstance.check(node, makeContext({ file }))).toBeNull();
   });
 
+  it("case-sensitive: 'button' does not match component 'Button'", () => {
+    const file = makeFile({
+      components: {
+        "comp-1": { key: "k1", name: "Button", description: "" },
+      },
+    });
+    const node = makeNode({ type: "FRAME", name: "button" });
+    expect(detachedInstance.check(node, makeContext({ file }))).toBeNull();
+  });
+
+  it("word boundary: 'Discard' does not match component 'Card'", () => {
+    const file = makeFile({
+      components: {
+        "comp-1": { key: "k1", name: "Card", description: "" },
+      },
+    });
+    const node = makeNode({ type: "FRAME", name: "Discard" });
+    expect(detachedInstance.check(node, makeContext({ file }))).toBeNull();
+  });
+
   it("returns null when file has no components", () => {
     const node = makeNode({ type: "FRAME", name: "SomeFrame" });
     expect(detachedInstance.check(node, makeContext())).toBeNull();
diff --git a/src/core/rules/component/index.ts b/src/core/rules/component/index.ts
index 211e9249..31f5bcfa 100644
--- a/src/core/rules/component/index.ts
+++ b/src/core/rules/component/index.ts
@@ -295,12 +295,12 @@ const detachedInstanceCheck: RuleCheckFn = (node, context) => {
   // Heuristic: Frame with a name that looks like it came from a component
   if (node.type !== "FRAME") return null;
 
-  // Check if there's a component in the file with a similar name
+  // Check if there's a component in the file with a matching name (word boundary)
   const components = context.file.components;
-  const nodeName = node.name.toLowerCase();
 
   for (const [, component] of Object.entries(components)) {
-    if (nodeName.includes(component.name.toLowerCase())) {
+    const pattern = new RegExp(`\\b${component.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+    if (pattern.test(node.name)) {
       // This frame might be a detached instance of this component
       return {
         ruleId: detachedInstanceDef.id,
diff --git a/src/core/rules/component/missing-component.test.ts b/src/core/rules/component/missing-component.test.ts
index 9effff94..17b2bd18 100644
--- a/src/core/rules/component/missing-component.test.ts
+++ b/src/core/rules/component/missing-component.test.ts
@@ -74,7 +74,7 @@ describe("missing-component — Stage 1: Component exists but not used", () => {
       id: "0:1",
       name: "Document",
       type: "DOCUMENT",
-      children: [frame, makeNode({ id: "f:2", name: "Card" })],
+      children: [frame],
     });
 
     const ctx = makeContext({
@@ -118,11 +118,12 @@ describe("missing-component — Stage 1: Component exists but not used", () => {
   it("only flags first occurrence (dedup)", () => {
     const frameA = makeNode({ id: "f:1", name: "Button" });
     const frameB = makeNode({ id: "f:2", name: "Button" });
+    const frameC = makeNode({ id: "f:3", name: "Button" });
     const doc = makeNode({
       id: "0:1",
       name: "Document",
       type: "DOCUMENT",
-      children: [frameA, frameB],
+      children: [frameA, frameB, frameC],
     });
 
     const ctx = makeContext({
@@ -134,12 +135,13 @@ describe("missing-component — Stage 1: Component exists but not used", () => {
       }),
     });
 
-    // First call flags
+    // First call on frameA flags (stage 1: unused-component, frameA is first frame)
     const result1 = missingComponent.check(frameA, ctx);
     expect(result1).not.toBeNull();
+    expect(result1!.subType).toBe("unused-component");
 
-    // Second call with same name is deduped
-    const result2 = missingComponent.check(frameA, ctx);
+    // frameB is not first frame → stage 1 deduped, stage 2 skips (not first frame)
+    const result2 = missingComponent.check(frameB, ctx);
     expect(result2).toBeNull();
   });
 
@@ -179,19 +181,18 @@ describe("missing-component — Stage 2: Name-based repetition", () => {
 
   it("returns null below minRepetitions threshold", () => {
     const frameA = makeNode({ id: "f:1", name: "Card" });
-    const frameB = makeNode({ id: "f:2", name: "Card" });
     const doc = makeNode({
       id: "0:1",
       name: "Document",
       type: "DOCUMENT",
-      children: [frameA, frameB],
+      children: [frameA],
     });
 
     const ctx = makeContext({
       file: makeFile({ document: doc }),
     });
 
-    // Default minRepetitions is 3, only 2 frames
+    // Default minRepetitions is 2, only 1 frame
     expect(missingComponent.check(frameA, ctx)).toBeNull();
   });
 
@@ -724,11 +725,12 @@ describe("missing-component — General", () => {
   it("fresh analysisState clears dedup state", () => {
     const frameA = makeNode({ id: "f:1", name: "Button" });
     const frameB = makeNode({ id: "f:2", name: "Button" });
+    const frameC = makeNode({ id: "f:3", name: "Button" });
     const doc = makeNode({
       id: "0:1",
       name: "Document",
       type: "DOCUMENT",
-      children: [frameA, frameB],
+      children: [frameA, frameB, frameC],
     });
 
     const file = makeFile({
@@ -742,9 +744,8 @@ describe("missing-component — General", () => {
 
     // First call flags (Stage 1)
     expect(missingComponent.check(frameA, ctx)).not.toBeNull();
-
-    // Deduped
-    expect(missingComponent.check(frameA, ctx)).toBeNull();
+    // frameB: not first frame → deduped
+    expect(missingComponent.check(frameB, ctx)).toBeNull();
 
     // Fresh analysisState simulates a new analysis run — should flag again
     analysisState = new Map();
diff --git a/src/core/rules/naming/default-name.test.ts b/src/core/rules/naming/default-name.test.ts
deleted file mode 100644
index 943333d5..00000000
--- a/src/core/rules/naming/default-name.test.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { makeNode, makeFile, makeContext } from "../test-helpers.js";
-import { defaultName } from "./index.js";
-
-describe("default-name", () => {
-  it("has correct rule definition metadata", () => {
-    expect(defaultName.definition.id).toBe("default-name");
-    expect(defaultName.definition.category).toBe("minor");
-  });
-
-  it.each([
-    "Frame 1",
-    "Frame",
-    "Group 12",
-    "Ellipse",
-    "Vector 1",
-    "Line 5",
-    "Text 2",
-    "Component 1",
-    "Instance 3",
-  ])("flags default name: %s", (name) => {
-    const node = makeNode({ name });
-    const result = defaultName.check(node, makeContext());
-    expect(result).not.toBeNull();
-    expect(result!.ruleId).toBe("default-name");
-  });
-
-  it("returns null for semantic names", () => {
-    const node = makeNode({ name: "ProductCard" });
-    expect(defaultName.check(node, makeContext())).toBeNull();
-  });
-
-  it("returns null for excluded name patterns", () => {
-    const node = makeNode({ name: "Icon Badge" });
-    expect(defaultName.check(node, makeContext())).toBeNull();
-  });
-
-  it("returns null when name is empty", () => {
-    const node = makeNode({ name: "" });
-    expect(defaultName.check(node, makeContext())).toBeNull();
-  });
-});
diff --git a/src/core/rules/naming/index.ts b/src/core/rules/naming/index.ts
index 14514891..0d784c5d 100644
--- a/src/core/rules/naming/index.ts
+++ b/src/core/rules/naming/index.ts
@@ -1,6 +1,6 @@
 import type { RuleCheckFn, RuleDefinition } from "../../contracts/rule.js";
 import { defineRule } from "../rule-registry.js";
-import { defaultNameMsg, getDefaultNameSubType, nonSemanticNameMsg, inconsistentNamingMsg, nonStandardNamingMsg } from "../rule-messages.js";
+import { getDefaultNameSubType, nonSemanticNameMsg, inconsistentNamingMsg, nonStandardNamingMsg } from "../rule-messages.js";
 import { isExcludedName, isDefaultName, isNonSemanticName, STANDARD_STATE_NAMES, STATE_NAME_SUGGESTIONS, STATE_LIKE_PATTERN } from "../node-semantics.js";
 
 function detectNamingConvention(name: string): string | null {
@@ -14,67 +14,51 @@ function detectNamingConvention(name: string): string | null {
 }
 
 // ============================================
-// default-name
-// ============================================
-
-const defaultNameDef: RuleDefinition = {
-  id: "default-name",
-  name: "Default Name",
-  category: "minor",
-  why: "Default names like 'Frame 123' give AI no semantic context to choose appropriate HTML tags or class names",
-  impact: "AI generates generic <div> wrappers instead of semantic elements like <header>, <nav>, <article>",
-  fix: "Rename with a descriptive name (e.g., 'Header', 'ProductCard') so AI can infer semantic structure",
-};
-
-const defaultNameCheck: RuleCheckFn = (node, context) => {
-  if (!node.name) return null;
-  if (isExcludedName(node.name)) return null;
-  if (!isDefaultName(node.name)) return null;
-
-  return {
-    ruleId: defaultNameDef.id,
-    subType: getDefaultNameSubType(node.type),
-    nodeId: node.id,
-    nodePath: context.path.join(" > "),
-    message: defaultNameMsg(node.type, node.name),
-  };
-};
-
-export const defaultName = defineRule({
-  definition: defaultNameDef,
-  check: defaultNameCheck,
-});
-
-// ============================================
-// non-semantic-name
+// non-semantic-name (merged: default-name + non-semantic-name)
 // ============================================
 
 const nonSemanticNameDef: RuleDefinition = {
   id: "non-semantic-name",
   name: "Non-Semantic Name",
   category: "minor",
-  why: "Shape names like 'Rectangle' tell AI nothing about the element's role in the UI",
-  impact: "AI cannot distinguish a divider from a background from a border — all look like 'Rectangle'",
-  fix: "Use purpose-driven names (e.g., 'Divider', 'Avatar') so AI generates meaningful markup",
+  why: "Default or shape names give AI no semantic context — it cannot choose appropriate HTML tags or class names",
+  impact: "AI generates generic <div> wrappers instead of semantic elements like <header>, <nav>, <article>",
+  fix: "Rename with a descriptive, purpose-driven name (e.g., 'Header', 'ProductCard', 'Divider')",
 };
 
 const nonSemanticNameCheck: RuleCheckFn = (node, context) => {
   if (!node.name) return null;
   if (isExcludedName(node.name)) return null;
-  if (!isNonSemanticName(node.name)) return null;
 
-  // Allow non-semantic names for actual shape primitives at leaf level
-  if (!node.children || node.children.length === 0) {
-    const shapeTypes = ["RECTANGLE", "ELLIPSE", "VECTOR", "LINE", "STAR", "REGULAR_POLYGON"];
-    if (shapeTypes.includes(node.type)) return null;
+  // Check 1: Figma default names (Frame 1, Group 2, etc.)
+  if (isDefaultName(node.name)) {
+    return {
+      ruleId: nonSemanticNameDef.id,
+      subType: getDefaultNameSubType(node.type),
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: nonSemanticNameMsg(node.type, node.name),
+    };
   }
 
-  return {
-    ruleId: nonSemanticNameDef.id,
-    nodeId: node.id,
-    nodePath: context.path.join(" > "),
-    message: nonSemanticNameMsg(node.type, node.name),
-  };
+  // Check 2: Shape-only names (rectangle, ellipse, vector, etc.)
+  if (isNonSemanticName(node.name)) {
+    // Allow shape names for actual shape primitives at leaf level
+    if (!node.children || node.children.length === 0) {
+      const shapeTypes = ["RECTANGLE", "ELLIPSE", "VECTOR", "LINE", "STAR", "REGULAR_POLYGON"];
+      if (shapeTypes.includes(node.type)) return null;
+    }
+
+    return {
+      ruleId: nonSemanticNameDef.id,
+      subType: "shape-name" as const,
+      nodeId: node.id,
+      nodePath: context.path.join(" > "),
+      message: nonSemanticNameMsg(node.type, node.name),
+    };
+  }
+
+  return null;
 };
 
 export const nonSemanticName = defineRule({
diff --git a/src/core/rules/naming/non-semantic-name.test.ts b/src/core/rules/naming/non-semantic-name.test.ts
index 677ae9aa..a3d1d8de 100644
--- a/src/core/rules/naming/non-semantic-name.test.ts
+++ b/src/core/rules/naming/non-semantic-name.test.ts
@@ -7,21 +7,46 @@ describe("non-semantic-name", () => {
     expect(nonSemanticName.definition.category).toBe("minor");
   });
 
-  it("flags non-semantic name on container node", () => {
-    const node = makeNode({ type: "FRAME", name: "ellipse", children: [makeNode()] });
+  // Default name detection (merged from default-name) — exact subType per node type
+  it.each([
+    { name: "Frame 1", type: "FRAME", expectedSubType: "frame" },
+    { name: "Group 12", type: "GROUP", expectedSubType: "group" },
+    { name: "Ellipse", type: "ELLIPSE", expectedSubType: "shape" },
+    { name: "Vector 1", type: "VECTOR", expectedSubType: "vector" },
+    { name: "Text 2", type: "TEXT", expectedSubType: "text" },
+    { name: "Component 1", type: "COMPONENT", expectedSubType: "component" },
+    { name: "Instance 3", type: "INSTANCE", expectedSubType: "instance" },
+  ] as const)("flags default name $name → subType $expectedSubType", ({ name, type, expectedSubType }) => {
+    const node = makeNode({ name, type: type as any });
     const result = nonSemanticName.check(node, makeContext());
     expect(result).not.toBeNull();
     expect(result!.ruleId).toBe("non-semantic-name");
+    expect(result!.subType).toBe(expectedSubType);
   });
 
-  it.each(["ellipse", "vector", "line", "polygon", "star", "path", "shape", "fill", "stroke"])(
-    "flags non-semantic name: %s (on container)",
+  // Shape name detection (names only in NON_SEMANTIC_NAMES, not DEFAULT_NAME_PATTERNS)
+  it.each(["polygon", "star", "path", "shape", "fill", "stroke"])(
+    "flags shape name: %s (on container)",
     (name) => {
       const node = makeNode({ type: "FRAME", name, children: [makeNode()] });
-      expect(nonSemanticName.check(node, makeContext())).not.toBeNull();
+      const result = nonSemanticName.check(node, makeContext());
+      expect(result).not.toBeNull();
+      expect(result!.subType).toBe("shape-name");
     },
   );
 
+  // Names that overlap DEFAULT_NAME_PATTERNS — caught as default names, not shape names
+  it.each(["ellipse", "vector", "line"])(
+    "flags %s as default name (overlaps with Figma defaults)",
+    (name) => {
+      const node = makeNode({ type: "FRAME", name, children: [makeNode()] });
+      const result = nonSemanticName.check(node, makeContext());
+      expect(result).not.toBeNull();
+      expect(result!.subType).toBe("frame"); // FRAME type → caught by isDefaultName first
+    },
+  );
+
+  // Exclusions
   it.each(["rectangle", "image"])(
     "returns null for %s (excluded by name pattern)",
     (name) => {
@@ -30,23 +55,18 @@ describe("non-semantic-name", () => {
     },
   );
 
-  it("allows non-semantic names on leaf shape primitives", () => {
-    const node = makeNode({ type: "RECTANGLE", name: "vector" });
-    expect(nonSemanticName.check(node, makeContext())).toBeNull();
-  });
-
-  it("allows non-semantic names on leaf ELLIPSE", () => {
-    const node = makeNode({ type: "ELLIPSE", name: "ellipse" });
+  it("allows shape names on leaf shape primitives", () => {
+    const node = makeNode({ type: "ELLIPSE" as any, name: "polygon" });
     expect(nonSemanticName.check(node, makeContext())).toBeNull();
   });
 
   it("returns null for semantic names", () => {
-    const node = makeNode({ name: "Divider" });
+    const node = makeNode({ name: "ProductCard" });
     expect(nonSemanticName.check(node, makeContext())).toBeNull();
   });
 
   it("returns null for excluded name patterns", () => {
-    const node = makeNode({ name: "icon" });
+    const node = makeNode({ name: "Icon Badge" });
     expect(nonSemanticName.check(node, makeContext())).toBeNull();
   });
 });
diff --git a/src/core/rules/rule-config.ts b/src/core/rules/rule-config.ts
index fdccad0b..36bfdcd0 100644
--- a/src/core/rules/rule-config.ts
+++ b/src/core/rules/rule-config.ts
@@ -31,7 +31,6 @@ export const RULE_ID_CATEGORY: Record<RuleId, Category> = {
   "missing-prototype": "interaction",
   // Minor
   "non-standard-naming": "minor",
-  "default-name": "minor",
   "non-semantic-name": "minor",
   "inconsistent-naming-convention": "minor",
 };
@@ -84,7 +83,7 @@ export const RULE_CONFIGS: Record<RuleId, RuleConfig> = {
     score: -7,
     enabled: true,
     options: {
-      minRepetitions: 3,
+      minRepetitions: 2,
       structureMinRepetitions: 2,
       maxFingerprintDepth: 3,
     },
@@ -119,7 +118,7 @@ export const RULE_CONFIGS: Record<RuleId, RuleConfig> = {
     score: -2,
     enabled: true,
     options: {
-      gridBase: 4,
+      gridBase: 2,
     },
   },
 
@@ -141,11 +140,6 @@ export const RULE_CONFIGS: Record<RuleId, RuleConfig> = {
     score: -1,
     enabled: true,
   },
-  "default-name": {
-    severity: "suggestion",
-    score: -1,
-    enabled: true,
-  },
   "non-semantic-name": {
     severity: "suggestion",
     score: -1,
diff --git a/src/core/rules/rule-exceptions.test.ts b/src/core/rules/rule-exceptions.test.ts
index c70ca472..70a79eff 100644
--- a/src/core/rules/rule-exceptions.test.ts
+++ b/src/core/rules/rule-exceptions.test.ts
@@ -134,13 +134,6 @@ describe("isSizeConstraintExempt", () => {
     expect(isSizeConstraintExempt(node, makeContext())).toBe(true);
   });
 
-  it("exempts small elements (width <= 200)", () => {
-    const node = makeNode({
-      absoluteBoundingBox: { x: 0, y: 0, width: 150, height: 40 },
-    });
-    expect(isSizeConstraintExempt(node, makeContext())).toBe(true);
-  });
-
   it("exempts when parent has maxWidth", () => {
     const parent = makeNode({ maxWidth: 1200 });
     const node = makeNode({});
@@ -152,62 +145,40 @@ describe("isSizeConstraintExempt", () => {
     expect(isSizeConstraintExempt(node, makeContext({ depth: 1 }))).toBe(true);
   });
 
-  it("exempts when all siblings are FILL", () => {
-    const node = makeNode({ layoutSizingHorizontal: "FILL" as any });
-    const sibling = makeNode({ layoutSizingHorizontal: "FILL" as any });
-    const ctx = makeContext({ siblings: [node, sibling] });
-    expect(isSizeConstraintExempt(node, ctx)).toBe(true);
-  });
-
-  it("does not exempt when siblings have mixed sizing", () => {
-    const node = makeNode({
-      absoluteBoundingBox: { x: 0, y: 0, width: 400, height: 100 },
-      layoutSizingHorizontal: "FILL" as any,
-    });
-    const sibling = makeNode({ layoutSizingHorizontal: "FIXED" as any });
-    const ctx = makeContext({ siblings: [node, sibling] });
-    expect(isSizeConstraintExempt(node, ctx)).toBe(false);
-  });
-
-  it("exempts inside GRID layout", () => {
+  it("does not exempt inside GRID layout", () => {
     const parent = makeNode({ layoutMode: "GRID" as any });
     const node = makeNode({
       absoluteBoundingBox: { x: 0, y: 0, width: 400, height: 100 },
-      layoutSizingHorizontal: "FILL" as any,
     });
-    const sibling = makeNode({ layoutSizingHorizontal: "FIXED" as any });
-    expect(isSizeConstraintExempt(node, makeContext({ parent, siblings: [node, sibling] }))).toBe(true);
+    expect(isSizeConstraintExempt(node, makeContext({ parent }))).toBe(false);
   });
 
-  it("exempts inside flex wrap", () => {
+  it("does not exempt inside flex wrap", () => {
     const parent = makeNode({ layoutWrap: "WRAP" as any });
     const node = makeNode({
       absoluteBoundingBox: { x: 0, y: 0, width: 400, height: 100 },
-      layoutSizingHorizontal: "FILL" as any,
     });
-    const sibling = makeNode({ layoutSizingHorizontal: "FIXED" as any });
-    expect(isSizeConstraintExempt(node, makeContext({ parent, siblings: [node, sibling] }))).toBe(true);
-  });
-
-  it("exempts TEXT nodes", () => {
-    const parent = makeNode({ layoutMode: "HORIZONTAL" as any });
-    const node = makeNode({ type: "TEXT" as any, layoutSizingHorizontal: "FILL" as any });
-    const ctx = makeContext({
-      parent,
-      siblings: [node, makeNode({ layoutSizingHorizontal: "FIXED" as any })],
-    });
-    expect(isSizeConstraintExempt(node, ctx)).toBe(true);
+    expect(isSizeConstraintExempt(node, makeContext({ parent }))).toBe(false);
   });
 });
 
 describe("isFixedSizeExempt", () => {
-  it("exempts small elements (icons)", () => {
+  it("exempts visual-only nodes (vector icons)", () => {
     const node = makeNode({
+      type: "VECTOR" as any,
       absoluteBoundingBox: { x: 0, y: 0, width: 24, height: 24 },
     });
     expect(isFixedSizeExempt(node)).toBe(true);
   });
 
+  it("does not exempt plain small frame (no longer size-based)", () => {
+    const node = makeNode({
+      absoluteBoundingBox: { x: 0, y: 0, width: 24, height: 24 },
+      fills: [{ type: "SOLID" }],
+    });
+    expect(isFixedSizeExempt(node)).toBe(false);
+  });
+
   it("exempts nodes with image fills", () => {
     const node = makeNode({
       absoluteBoundingBox: { x: 0, y: 0, width: 200, height: 200 },
diff --git a/src/core/rules/rule-exceptions.ts b/src/core/rules/rule-exceptions.ts
index 5b1f94da..49164fe3 100644
--- a/src/core/rules/rule-exceptions.ts
+++ b/src/core/rules/rule-exceptions.ts
@@ -40,29 +40,12 @@ export function isSizeConstraintExempt(node: AnalysisNode, context: RuleContext)
   // Already has maxWidth
   if (node.maxWidth !== undefined) return true;
 
-  // Small elements — won't stretch problematically
-  if (node.absoluteBoundingBox && node.absoluteBoundingBox.width <= 200) return true;
-
   // Parent already has maxWidth — parent constrains the stretch
   if (context.parent?.maxWidth !== undefined) return true;
 
   // Root-level frames — they represent the screen itself
   if (context.depth <= 1) return true;
 
-  // All siblings are FILL (e.g. single item or list view) — parent controls the width
-  if (context.siblings && context.siblings.length > 0) {
-    if (context.siblings.every((s) => s.layoutSizingHorizontal === "FILL")) return true;
-  }
-
-  // Inside grid layout — grid controls sizing
-  if (context.parent?.layoutMode === "GRID") return true;
-
-  // Inside flex wrap — wrap layout controls sizing per row
-  if (context.parent?.layoutWrap === "WRAP") return true;
-
-  // Text nodes — content length provides natural sizing
-  if (node.type === "TEXT") return true;
-
   return false;
 }
 
@@ -72,12 +55,7 @@ export function isSizeConstraintExempt(node: AnalysisNode, context: RuleContext)
 
 /** Nodes that are allowed to use fixed sizing inside auto-layout */
 export function isFixedSizeExempt(node: AnalysisNode): boolean {
-  // Small fixed elements (icons, avatars) — intentionally fixed
-  if (node.absoluteBoundingBox) {
-    const { width, height } = node.absoluteBoundingBox;
-    if (width <= 48 && height <= 48) return true;
-  }
-
+  // Visual-only nodes (icons, images, shapes) — intentionally fixed
   if (isVisualOnlyNode(node)) return true;
 
   // Excluded names (nav, header, etc.)
diff --git a/src/core/rules/rule-messages.ts b/src/core/rules/rule-messages.ts
index 97e8cc4b..57ad9837 100644
--- a/src/core/rules/rule-messages.ts
+++ b/src/core/rules/rule-messages.ts
@@ -120,11 +120,11 @@ export const nonStandardNamingMsg = {
     `"${name}" has non-standard state name "${nonStandard}" — use "${suggestion}" for dev-friendly naming`,
 };
 
-// ── default-name ─────────────────────────────────────────────────────────────
+// ── non-semantic-name (merged: default-name + non-semantic-name) ─────────────
 
-export type DefaultNameSubType = "frame" | "group" | "vector" | "shape" | "text" | "image" | "component" | "instance";
+export type NonSemanticNameSubType = "frame" | "group" | "vector" | "shape" | "text" | "image" | "component" | "instance" | "shape-name";
 
-const DEFAULT_NAME_SUBTYPE_MAP: Record<string, DefaultNameSubType> = {
+const DEFAULT_NAME_SUBTYPE_MAP: Record<string, NonSemanticNameSubType> = {
   FRAME: "frame",
   GROUP: "group",
   RECTANGLE: "shape",
@@ -140,17 +140,12 @@ const DEFAULT_NAME_SUBTYPE_MAP: Record<string, DefaultNameSubType> = {
   INSTANCE: "instance",
 };
 
-export function getDefaultNameSubType(nodeType: string): DefaultNameSubType {
+export function getDefaultNameSubType(nodeType: string): NonSemanticNameSubType {
   return DEFAULT_NAME_SUBTYPE_MAP[nodeType] ?? "frame";
 }
 
-export const defaultNameMsg = (type: string, name: string) =>
-  `${type} "${name}" has a default name — rename to describe its purpose (e.g., "Header", "ProductCard")`;
-
-// ── non-semantic-name ────────────────────────────────────────────────────────
-
 export const nonSemanticNameMsg = (type: string, name: string) =>
-  `${type} "${name}" is a non-semantic name — rename to describe its role (e.g., "Divider", "Background")`;
+  `${type} "${name}" is a non-semantic name — rename to describe its role (e.g., "Header", "ProductCard", "Divider")`;
 
 // ── missing-interaction-state ─────────────────────────────────────────────────
 
diff --git a/src/core/rules/structure/index.ts b/src/core/rules/structure/index.ts
index 177651c3..bf6f39a1 100644
--- a/src/core/rules/structure/index.ts
+++ b/src/core/rules/structure/index.ts
@@ -218,20 +218,46 @@ const missingSizeConstraintCheck: RuleCheckFn = (node, context) => {
   if (!isContainerNode(node) && !hasTextContent(node)) return null;
   // Skip if not in Auto Layout context
   if (!context.parent || !hasAutoLayout(context.parent)) return null;
-  // Only flag FILL containers — FIXED/HUG don't need min/max-width
-  if (node.layoutSizingHorizontal !== "FILL") return null;
 
-  if (isSizeConstraintExempt(node, context)) return null;
+  const nodePath = context.path.join(" > ");
 
-  const currentWidth = node.absoluteBoundingBox ? `${node.absoluteBoundingBox.width}px` : "unknown";
+  // Check 1: wrap parent → FILL children need min-width
+  if (context.parent.layoutWrap === "WRAP" && node.layoutSizingHorizontal === "FILL" && node.minWidth === undefined) {
+    return {
+      ruleId: missingSizeConstraintDef.id,
+      subType: "wrap" as const,
+      nodeId: node.id,
+      nodePath,
+      message: missingSizeConstraintMsg.wrap(node.name),
+    };
+  }
 
-  return {
-    ruleId: missingSizeConstraintDef.id,
-    subType: "max-width" as const,
-    nodeId: node.id,
-    nodePath: context.path.join(" > "),
-    message: missingSizeConstraintMsg.maxWidth(node.name, currentWidth),
-  };
+  // Check 2: grid parent → FILL children need size constraints
+  if (context.parent.layoutMode === "GRID" && node.layoutSizingHorizontal === "FILL" && node.minWidth === undefined && node.maxWidth === undefined) {
+    return {
+      ruleId: missingSizeConstraintDef.id,
+      subType: "grid" as const,
+      nodeId: node.id,
+      nodePath,
+      message: missingSizeConstraintMsg.grid(node.name),
+    };
+  }
+
+  // Check 3: FILL containers need max-width
+  if (node.layoutSizingHorizontal === "FILL") {
+    if (isSizeConstraintExempt(node, context)) return null;
+
+    const currentWidth = node.absoluteBoundingBox ? `${node.absoluteBoundingBox.width}px` : "unknown";
+    return {
+      ruleId: missingSizeConstraintDef.id,
+      subType: "max-width" as const,
+      nodeId: node.id,
+      nodePath,
+      message: missingSizeConstraintMsg.maxWidth(node.name, currentWidth),
+    };
+  }
+
+  return null;
 };
 
 export const missingSizeConstraint = defineRule({
@@ -264,8 +290,6 @@ const nonLayoutContainerCheck: RuleCheckFn = (node, context) => {
   }
 
   if (node.type === "SECTION") {
-    // Only flag Sections that have children (used as layout container)
-    if (!node.children || node.children.length === 0) return null;
     return {
       ruleId: nonLayoutContainerDef.id,
       subType: "section" as const,
diff --git a/src/core/rules/structure/responsive-fields.test.ts b/src/core/rules/structure/responsive-fields.test.ts
index 9f4f9fab..1027df59 100644
--- a/src/core/rules/structure/responsive-fields.test.ts
+++ b/src/core/rules/structure/responsive-fields.test.ts
@@ -173,7 +173,7 @@ describe("missing-size-constraint", () => {
     expect(issues).toHaveLength(0);
   });
 
-  it("does not flag when all siblings are FILL (e.g. list view)", () => {
+  it("flags when all siblings are FILL (max-width still needed)", () => {
     const file = makeFile(
       makeNode({
         name: "Page",
@@ -205,7 +205,7 @@ describe("missing-size-constraint", () => {
     const issues = result.issues.filter(
       (i) => i.rule.definition.id === "missing-size-constraint",
     );
-    expect(issues).toHaveLength(0);
+    expect(issues.length).toBeGreaterThan(0);
   });
 
   it("does not flag when parent has maxWidth", () => {
@@ -244,7 +244,7 @@ describe("missing-size-constraint", () => {
     expect(issues).toHaveLength(0);
   });
 
-  it("does not flag inside grid layout", () => {
+  it("flags inside grid layout (grid subType)", () => {
     const file = makeFile(
       makeNode({
         name: "Page",
@@ -270,10 +270,11 @@ describe("missing-size-constraint", () => {
     const issues = result.issues.filter(
       (i) => i.rule.definition.id === "missing-size-constraint",
     );
-    expect(issues).toHaveLength(0);
+    expect(issues.length).toBeGreaterThan(0);
+    expect(issues[0]!.violation.subType).toBe("grid");
   });
 
-  it("does not flag inside flex wrap", () => {
+  it("flags inside flex wrap (wrap subType)", () => {
     const file = makeFile(
       makeNode({
         name: "Page",
@@ -306,7 +307,8 @@ describe("missing-size-constraint", () => {
     const issues = result.issues.filter(
       (i) => i.rule.definition.id === "missing-size-constraint",
     );
-    expect(issues).toHaveLength(0);
+    expect(issues.length).toBeGreaterThan(0);
+    expect(issues[0]!.violation.subType).toBe("wrap");
   });
 
   it("does not flag FIXED container", () => {
diff --git a/src/core/rules/token/index.ts b/src/core/rules/token/index.ts
index 3f9885cf..6fafccb3 100644
--- a/src/core/rules/token/index.ts
+++ b/src/core/rules/token/index.ts
@@ -94,7 +94,7 @@ const rawValueCheck: RuleCheckFn = (node, context) => {
   }
 
   // Check 4: Raw opacity (non-default opacity without variable)
-  if (node.opacity !== undefined && !hasBoundVariable(node, "opacity")) {
+  if (node.opacity !== undefined && node.opacity < 1 && !hasBoundVariable(node, "opacity")) {
     return {
       ruleId: rawValueDef.id,
       subType: "opacity" as const,