atdd 0.7.3__tar.gz → 0.7.4__tar.gz

{atdd-0.7.3/src/atdd.egg-info → atdd-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atdd
-Version: 0.7.3
+Version: 0.7.4
 Summary: ATDD Platform - Acceptance Test Driven Development toolkit
 License: MIT
 Requires-Python: >=3.10

{atdd-0.7.3 → atdd-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atdd"
-version = "0.7.3"
+version = "0.7.4"
 description = "ATDD Platform - Acceptance Test Driven Development toolkit"
 requires-python = ">=3.10"
 readme = "README.md"

{atdd-0.7.3 → atdd-0.7.4}/src/atdd/planner/conventions/wagon.convention.yaml

@@ -177,30 +177,35 @@ artifact_contracts:
   note: "Full artifact contract conventions defined in artifact.convention.yaml"
 
   urn_format:
-    contract_urn: "contract:domain:resource (e.g., contract:ux:foundations, contract:match:result)"
-    telemetry_urn: "telemetry:domain:resource[.category] (e.g., telemetry:ux:foundations, telemetry:ux:foundations.colors)"
+    contract_urn: "contract:{theme}(:{category})*:{aspect}(.{variant})?"
+    telemetry_urn: "telemetry:{theme}(:{category})*:{aspect}(.{variant})?"
+    examples:
+      - "contract:commons:ux:foundations:color"
+      - "contract:mechanic:decision.choice"
+      - "contract:sensory:gesture.raw"
+      - "telemetry:commons:ux:foundations"
 
     telemetry_filesystem:
       description: "Telemetry URN maps to filesystem directory containing signal files"
-      pattern: "telemetry/{domain}/{resource}[/{category}]/{signal-type}.{plane}[.{measure}].json"
-      urn_to_path: "telemetry:{domain}:{resource}[.{category}] → telemetry/{domain}/{resource}[/{category}]/"
+      pattern: "telemetry/{segments}/{signal-type}.{plane}[.{measure}].json"
+      urn_to_path: "telemetry:{theme}:{segments} → telemetry/{theme}/{segments}/"
 
       examples:
         - urn: "telemetry:mechanic:decision.choice"
-          path: "telemetry/decision/choice/"
+          path: "telemetry/mechanic/decision/choice/"
           files:
             - "metric.db.count.json"
             - "metric.be.duration.json"
             - "event.be.json"
 
-        - urn: "telemetry:ux:foundations"
-          path: "telemetry/ux/foundations/"
+        - urn: "telemetry:commons:ux:foundations"
+          path: "telemetry/commons/ux/foundations/"
           files:
             - "metric.ui.render_latency.json"
             - "event.ui.json"
 
-        - urn: "telemetry:ux:foundations.colors"
-          path: "telemetry/ux/foundations/colors/"
+        - urn: "telemetry:commons:ux:foundations:color"
+          path: "telemetry/commons/ux/foundations/color/"
           files:
             - "metric.ui.render_latency.json"
             - "event.ui.json"
@@ -222,18 +227,21 @@ artifact_contracts:
 
   produce_artifacts:
     required_fields:
-      - name: "Artifact name (e.g., ux:foundations)"
-      - contract: "Contract URN or null (e.g., contract:ux:foundations)"
-      - telemetry: "Telemetry URN for observability and analytics or null (e.g., telemetry:ux:foundations)"
+      - name: "Artifact name (e.g., commons:ux:foundations)"
+      - contract: "Contract URN or null (e.g., contract:commons:ux:foundations)"
+      - telemetry: "Telemetry URN for observability and analytics or null (e.g., telemetry:commons:ux:foundations)"
     optional_fields:
       - to: "Visibility (internal|external), defaults to external"
       - urn: "Legacy artifact URN"
       - version: "Version string (e.g., v1)"
 
     example:
-      - name: ux:foundations
-        contract: contract:ux:foundations
-        telemetry: telemetry:ux:foundations
+      - name: commons:ux:foundations
+        contract: contract:commons:ux:foundations
+        telemetry: telemetry:commons:ux:foundations
+      - name: commons:ux:foundations:color
+        contract: contract:commons:ux:foundations:color
+        telemetry: telemetry:commons:ux:foundations:color
       - name: internal:cache
         contract: null
         telemetry: null
@@ -251,10 +259,10 @@ artifact_contracts:
 
     example:
       - name: appendix:mockup
-      - name: match:config
-        from: wagon:setup-match
-        contract: contract:match:config
-        telemetry: telemetry:match:config
+      - name: commons:ux:foundations
+        from: wagon:maintain-ux
+        contract: contract:commons:ux:foundations
+        telemetry: telemetry:commons:ux:foundations
 
   features_format:
     legacy_format:

atdd-0.7.4/src/atdd/tester/conventions/artifact.convention.yaml

@@ -0,0 +1,276 @@
+# Artifact Convention
+# Defines naming, versioning, organization, and API mapping rules for artifact-centric contracts
+# Aligned with canonical artifact-naming.convention.yaml v2.1
+
+description: "Artifact-centric contract system using theme-based hierarchical taxonomy with variant facets"
+
+naming:
+  logical_pattern: "{theme}(:{category})*:{aspect}(.{variant})?"
+  physical_pattern: "contracts/{theme}/{segments}/{aspect}[/{variant}].schema.json"
+  rationale: "Theme-based organization enables clear architectural boundaries. Colon separator denotes hierarchical descent (unlimited depth), dot separator denotes lateral variant (typically 0-1). Each segment becomes a directory level."
+
+  examples:
+    - logical: "commons:ux:foundations"
+      physical: "contracts/commons/ux/foundations.schema.json"
+
+    - logical: "commons:ux:foundations:color"
+      physical: "contracts/commons/ux/foundations/color.schema.json"
+
+    - logical: "mechanic:decision.choice"
+      physical: "contracts/mechanic/decision/choice.schema.json"
+
+    - logical: "match:result"
+      physical: "contracts/match/result.schema.json"
+
+    - logical: "sensory:gesture.raw"
+      physical: "contracts/sensory/gesture/raw.schema.json"
+
+versioning:
+  location: "Separate version field"
+  filename_pattern: "{segments}.schema.json"
+  id_pattern: "{artifact_name}"
+  version_field: "version"
+  rationale: "Version tracked in separate 'version' field, NOT embedded in $id. Allows artifact identity to remain stable across versions. Supports monolithic deployment with coordinated releases."
+
+  examples:
+    - artifact: "commons/ux/foundations/color.schema.json"
+      id_field: "commons:ux:foundations:color"
+      version_field: "1.0.0"
+
+    - artifact: "mechanic/decision/choice.schema.json"
+      id_field: "mechanic:decision.choice"
+      version_field: "1.0.0"
+
+    - artifact: "match/result.schema.json"
+      id_field: "match:result"
+      version_field: "1.2.3"
+
+    - artifact: "sensory/gesture/raw.schema.json"
+      id_field: "sensory:gesture.raw"
+      version_field: "1.0.0"
+
+organization:
+  strategy: "by_theme"
+  directory_structure: "contracts/{theme}/"
+  rationale: "Theme-based directories enable clear architectural boundaries. Each theme represents a bounded context. Unlimited hierarchical depth supported via colons."
+
+  structure:
+    root: "contracts/"
+    themes:
+      - "commons/"
+      - "match/"
+      - "mechanic/"
+      - "sensory/"
+      - "player/"
+      - "scenario/"
+      - "partnership/"
+      - "league/"
+      - "audience/"
+      - "monetization/"
+
+api_mapping:
+  description: "Artifact names map to REST API endpoints for external consumption. Hierarchy levels add path segments, variants treated as resources."
+  pattern: "/{theme}s/{id}/{segments}[/{variant}]"
+
+  methods:
+    new: POST
+    created: POST
+    registered: POST
+    started: POST
+    result: GET
+    active: GET
+    config: GET
+    events: GET
+    current: GET
+    foundations: GET
+    updated: PUT
+    closed: PUT
+    completed: PUT
+    terminated: DELETE
+    deleted: DELETE
+
+  examples:
+    - artifact: "commons:ux:foundations"
+      endpoint: "GET /commons/{id}/ux/foundations"
+      description: "Retrieve UX foundations"
+
+    - artifact: "commons:ux:foundations:color"
+      endpoint: "GET /commons/{id}/ux/foundations/color"
+      description: "Retrieve UX color foundations"
+
+    - artifact: "match:result"
+      endpoint: "GET /matches/{id}/result"
+      description: "Retrieve match result"
+
+    - artifact: "session:new"
+      endpoint: "POST /sessions"
+      description: "Create new session"
+
+    - artifact: "player:identity"
+      endpoint: "GET /players/{id}"
+      description: "Retrieve player identity"
+
+    - artifact: "match:config"
+      endpoint: "GET /matches/{id}/config"
+      description: "Retrieve match configuration"
+
+    - artifact: "player:updated"
+      endpoint: "PUT /players/{id}"
+      description: "Update player"
+
+    - artifact: "match:terminated"
+      endpoint: "DELETE /matches/{id}"
+      description: "Terminate match"
+
+ownership:
+  producer: "Generates artifact contract (wagon that declares artifact in produce[])"
+  consumer: "References existing contract (wagon that declares artifact in consume[])"
+  single_source: "One artifact = one JSON file. Multiple wagons reference same file. Zero duplication."
+
+  rules:
+    - "Producer wagon owns the artifact schema generation"
+    - "Consumer wagon validates artifact existence and references it"
+    - "Artifact path declared in wagon manifest contract: field"
+    - "Only producer generates; consumers must never modify"
+
+metadata:
+  description: "Artifact schemas include x-artifact-metadata for tooling and API generation"
+
+  fields:
+    theme: "Architectural theme (commons, match, mechanic, etc.)"
+    aspect: "Final leaf resource noun"
+    variant: "Optional lateral variation"
+    api:
+      method: "HTTP method (GET, POST, PUT, DELETE)"
+      path: "REST endpoint path"
+
+  example:
+    theme: "match"
+    aspect: "result"
+    api:
+      method: "GET"
+      path: "/matches/{id}/result"
+
+validation:
+  required_fields: ["$schema", "$id", "version", "title", "type", "properties"]
+  schema_compliance: "JSON Schema Draft-07"
+  id_pattern: "^[a-z]+(?::[a-z][a-z0-9-]*)+(?:\\.[a-z][a-z0-9-]*)?$"
+  version_pattern: "^\\d+\\.\\d+\\.\\d+$"
+
+artifact_urns:
+  urn_pattern:
+    format: "contract:{artifact_name}"
+    conversion_rule: "URN exactly matches artifact name - preserves colons for hierarchy and dots for variants. Pattern: contract:{theme}(:{category})*:{aspect}(.{variant})?"
+
+  examples:
+    artifact_to_urn:
+      - artifact_name: "commons:ux:foundations"
+        urn: "contract:commons:ux:foundations"
+
+      - artifact_name: "commons:ux:foundations:color"
+        urn: "contract:commons:ux:foundations:color"
+
+      - artifact_name: "mechanic:decision.choice"
+        urn: "contract:mechanic:decision.choice"
+
+      - artifact_name: "sensory:gesture.raw"
+        urn: "contract:sensory:gesture.raw"
+
+  bidirectional_linkage:
+    validation: "URN must resolve to a contract in the registry. All colons and dots preserved."
+
+  migration_strategy:
+    refactor_note: "Legacy URNs contract:{domain}:{resource}[.{category}] migrate to contract:{theme}(:{category})*:{aspect}(.{variant})?. Version suffix removed from $id."
+
+wagon_artifacts:
+  produce_example:
+    wagon: "maintain-ux"
+    produce:
+      - name: "commons:ux:foundations"
+        urn: "contract:commons:ux:foundations"
+        to: "external"
+
+      - name: "commons:ux:foundations:color"
+        urn: "contract:commons:ux:foundations:color"
+        to: "external"
+
+  consume_example:
+    wagon: "stage-characters"
+    consume:
+      - name: "commons:ux:foundations"
+        urn: "contract:commons:ux:foundations"
+        from: "wagon:maintain-ux"
+
+contract_artifacts:
+  id_field: "id: {artifact_name}"
+  urn_mapping: "URN contract:{artifact_name} maps directly to $id {artifact_name}"
+
+  example:
+    - id: "commons:ux:foundations"
+      version: "1.0.0"
+      path: "commons/ux/foundations.schema.json"
+      producer: "wagon:maintain-ux"
+      urn_match: "contract:commons:ux:foundations"
+
+    - id: "commons:ux:foundations:color"
+      version: "1.0.0"
+      path: "commons/ux/foundations/color.schema.json"
+      producer: "wagon:maintain-ux"
+      urn_match: "contract:commons:ux:foundations:color"
+
+    - id: "mechanic:decision.choice"
+      version: "1.0.0"
+      path: "mechanic/decision/choice.schema.json"
+      producer: "wagon:resolve-dilemmas"
+      urn_match: "contract:mechanic:decision.choice"
+
+demo_mode:
+  description: "Artifacts write to demo/contracts/artifacts/ when mode_demo: true"
+  path_prefix: "demo/contracts/artifacts/"
+
+examples:
+  complete_workflow:
+    - step: "Wagon declares artifact in produce[]"
+      example: |
+        produce:
+          - name: mechanic:decision.choice
+            to: external
+            contract: contracts/mechanic/decision/choice.schema.json
+
+    - step: "Tester agent classifies artifact ownership"
+      result: "producer: true, path: mechanic/decision/choice.schema.json"
+
+    - step: "Schema generation creates artifact"
+      output: "contracts/mechanic/decision/choice.schema.json"
+      content: |
+        {
+          "$schema": "http://json-schema.org/draft-07/schema#",
+          "$id": "mechanic:decision.choice",
+          "version": "1.0.0",
+          "title": "Decision Choice",
+          "type": "object",
+          "properties": {...},
+          "x-artifact-metadata": {
+            "theme": "mechanic",
+            "aspect": "decision",
+            "variant": "choice",
+            "api": {
+              "method": "POST",
+              "path": "/decisions"
+            }
+          }
+        }
+
+    - step: "Consumer wagon references artifact"
+      example: |
+        consume:
+          - name: mechanic:decision.choice
+            from: wagon:resolve-dilemmas
+            contract: contracts/mechanic/decision/choice.schema.json
+
+    - step: "Pack generation references (not embeds) artifact"
+      pack_manifest: |
+        produce:
+          - artifact: mechanic:decision.choice
+            contract: ../artifacts/mechanic/decision/choice.schema.json
+            owner: true

atdd-0.7.4/src/atdd/tester/validators/test_artifact_naming_category.py

@@ -0,0 +1,294 @@
+"""
+RED Tests for Artifact Naming Convention with Theme-Based Hierarchical Taxonomy
+
+SPEC: SPEC-TESTER-CONV-0059 through SPEC-TESTER-CONV-0067
+Feature: Artifact naming uses theme-based hierarchical pattern with variant facets
+Background:
+  - Colon separator denotes hierarchical descent (unlimited depth)
+  - Dot separator denotes lateral variant (typically 0-1)
+  - Pattern: {theme}(:{category})*:{aspect}(.{variant})?
+  - Examples use commons:ux:foundations:color instead of legacy ux:foundations
+"""
+
+import pytest
+import yaml
+from pathlib import Path
+
+
+@pytest.fixture
+def artifact_convention():
+    """Load artifact.convention.yaml"""
+    # File is at atdd/tester/audits/test_*.py, convention is at atdd/tester/conventions/
+    convention_path = Path(__file__).parent.parent / "conventions" / "artifact.convention.yaml"
+    assert convention_path.exists(), f"Convention file not found: {convention_path}"
+
+    with open(convention_path) as f:
+        return yaml.safe_load(f)
+
+
+# SPEC-TESTER-CONV-0059
+def test_logical_pattern_has_theme_hierarchy(artifact_convention):
+    """Logical naming pattern supports theme-based hierarchy with variants"""
+    naming = artifact_convention.get("naming", {})
+    logical_pattern = naming.get("logical_pattern")
+
+    assert logical_pattern == "{theme}(:{category})*:{aspect}(.{variant})?", \
+        f"Expected logical_pattern to be '{{theme}}(:{{category}})*:{{aspect}}(.{{variant}})?', got: {logical_pattern}"
+
+    # Verify rationale explains hierarchy vs variant
+    rationale = naming.get("rationale", "")
+    assert "colon" in rationale.lower() or "hierarchy" in rationale.lower(), \
+        "Rationale should explain colon separator for hierarchical descent"
+
+
+# SPEC-TESTER-CONV-0060
+def test_physical_pattern_has_segments(artifact_convention):
+    """Physical path pattern supports hierarchical segments"""
+    naming = artifact_convention.get("naming", {})
+    physical_pattern = naming.get("physical_pattern")
+
+    assert "contracts/" in physical_pattern and ".schema.json" in physical_pattern, \
+        f"Expected physical_pattern with contracts/ prefix and .schema.json extension, got: {physical_pattern}"
+
+    # Check examples demonstrate theme-based patterns
+    examples = naming.get("examples", [])
+    assert len(examples) >= 2, "Should have examples for various hierarchy depths"
+
+
+# SPEC-TESTER-CONV-0061
+def test_examples_use_theme_hierarchy(artifact_convention):
+    """Examples use theme-based hierarchy (commons:ux:foundations:color)"""
+    naming = artifact_convention.get("naming", {})
+    examples = naming.get("examples", [])
+
+    # Check for commons:ux:foundations hierarchy examples
+    ux_base = None
+    ux_deep = None
+
+    for example in examples:
+        if example.get("logical") == "commons:ux:foundations":
+            ux_base = example
+        if example.get("logical") == "commons:ux:foundations:color":
+            ux_deep = example
+
+    assert ux_base is not None, "Missing commons:ux:foundations base example"
+    assert "contracts/commons/ux/foundations" in ux_base.get("physical", ""), \
+        f"commons:ux:foundations should map to contracts/commons/ux/foundations path"
+
+    assert ux_deep is not None, "Missing commons:ux:foundations:color deep hierarchy example"
+    assert "contracts/commons/ux/foundations/color" in ux_deep.get("physical", ""), \
+        f"commons:ux:foundations:color should map to contracts/commons/ux/foundations/color path"
+
+
+# SPEC-TESTER-CONV-0061 (part 2)
+def test_no_legacy_domain_resource_examples(artifact_convention):
+    """No legacy domain:resource examples remain (should use theme-based)"""
+    naming = artifact_convention.get("naming", {})
+    examples = naming.get("examples", [])
+
+    for example in examples:
+        logical = example.get("logical", "")
+        # Legacy patterns like "ux:foundations" or "design:tokens" without theme prefix
+        if logical.count(":") == 1:
+            # Single colon is OK for simple patterns like "match:result"
+            pass
+        # Check no "ux:foundations.colors" dot-for-hierarchy pattern
+        assert ".colors" not in logical or logical.count(":") >= 2, \
+            f"Found legacy dot-for-hierarchy example: {logical}"
+
+
+# SPEC-TESTER-CONV-0062
+def test_api_pattern_has_theme_segments(artifact_convention):
+    """API mapping supports theme-based hierarchy"""
+    api_mapping = artifact_convention.get("api_mapping", {})
+    pattern = api_mapping.get("pattern")
+
+    # Pattern should include theme and segments
+    assert "{" in pattern and "}" in pattern, \
+        f"Expected API pattern with template variables, got: {pattern}"
+
+
+# SPEC-TESTER-CONV-0062 (part 2)
+def test_api_examples_include_theme_based(artifact_convention):
+    """API examples include theme-based patterns"""
+    api_mapping = artifact_convention.get("api_mapping", {})
+    examples = api_mapping.get("examples", [])
+
+    # Check for theme-based examples
+    has_commons_example = False
+    has_match_example = False
+
+    for example in examples:
+        artifact = example.get("artifact", "")
+        if artifact.startswith("commons:"):
+            has_commons_example = True
+        if artifact.startswith("match:"):
+            has_match_example = True
+
+    assert has_commons_example or has_match_example, \
+        "API examples should include theme-based patterns (commons:*, match:*, etc.)"
+
+
+# SPEC-TESTER-CONV-0063
+def test_urn_pattern_preserves_colons_and_dots(artifact_convention):
+    """URN pattern preserves colons for hierarchy and dots for variants"""
+    artifact_urns = artifact_convention.get("artifact_urns", {})
+    urn_pattern = artifact_urns.get("urn_pattern", {})
+
+    format_str = urn_pattern.get("format")
+    assert format_str == "contract:{artifact_name}", \
+        f"Expected URN format 'contract:{{artifact_name}}', got: {format_str}"
+
+    # Check conversion rule explains preservation
+    conversion_rule = urn_pattern.get("conversion_rule", "")
+    assert "colon" in conversion_rule.lower() or "hierarchy" in conversion_rule.lower(), \
+        "Conversion rule should explain colon preservation for hierarchy"
+
+
+# SPEC-TESTER-CONV-0063 (part 2)
+def test_urn_examples_use_theme_hierarchy(artifact_convention):
+    """URN examples use theme-based hierarchy"""
+    artifact_urns = artifact_convention.get("artifact_urns", {})
+    examples = artifact_urns.get("examples", {})
+    artifact_to_urn = examples.get("artifact_to_urn", [])
+
+    # Check for theme-based examples
+    has_theme_example = False
+    has_variant_example = False
+
+    for example in artifact_to_urn:
+        artifact_name = example.get("artifact_name", "")
+        urn = example.get("urn", "")
+
+        # Theme-based: multiple colons
+        if artifact_name.count(":") >= 2:
+            has_theme_example = True
+            # URN should match artifact with contract: prefix
+            assert urn == f"contract:{artifact_name}", \
+                f"URN should be 'contract:{artifact_name}', got: {urn}"
+
+        # Variant: has dot
+        if "." in artifact_name:
+            has_variant_example = True
+
+    assert has_theme_example, "Missing theme-based hierarchy URN example (multiple colons)"
+
+
+# SPEC-TESTER-CONV-0064
+def test_contract_id_unversioned(artifact_convention):
+    """Contract ID field uses unversioned artifact name"""
+    contract_artifacts = artifact_convention.get("contract_artifacts", {})
+    id_field = contract_artifacts.get("id_field")
+
+    # Should NOT have :v{version} suffix
+    assert ":v{version}" not in id_field and ":v1" not in id_field, \
+        f"ID field should be unversioned, got: {id_field}"
+
+    # Should reference artifact_name
+    assert "{artifact_name}" in id_field, \
+        f"ID field should reference artifact_name, got: {id_field}"
+
+
+# SPEC-TESTER-CONV-0064 (part 2)
+def test_contract_examples_use_theme_hierarchy(artifact_convention):
+    """Contract examples use theme-based hierarchy"""
+    contract_artifacts = artifact_convention.get("contract_artifacts", {})
+    examples = contract_artifacts.get("example", [])
+
+    # Check for theme-based examples
+    has_theme_example = False
+
+    for example in examples:
+        id_value = example.get("id", "")
+        # Theme-based: has multiple colons and NO :v suffix
+        if id_value.count(":") >= 2 and ":v" not in id_value:
+            has_theme_example = True
+            # Should have separate version field
+            assert "version" in example, \
+                f"Example should have separate version field, got: {example}"
+
+    assert has_theme_example, "Missing theme-based hierarchy contract example"
+
+
+# SPEC-TESTER-CONV-0065
+def test_wagon_examples_use_maintain_ux(artifact_convention):
+    """Wagon artifacts examples updated to maintain-ux"""
+    wagon_artifacts = artifact_convention.get("wagon_artifacts", {})
+    produce_example = wagon_artifacts.get("produce_example", {})
+
+    wagon_name = produce_example.get("wagon")
+    assert wagon_name == "maintain-ux", \
+        f"Expected producer wagon 'maintain-ux', got: {wagon_name}"
+
+
+# SPEC-TESTER-CONV-0065 (part 2)
+def test_wagon_produces_theme_hierarchy_artifacts(artifact_convention):
+    """Wagon produces theme-based hierarchy artifacts"""
+    wagon_artifacts = artifact_convention.get("wagon_artifacts", {})
+    produce_example = wagon_artifacts.get("produce_example", {})
+    produce = produce_example.get("produce", [])
+
+    # Check for theme-based artifacts
+    has_theme_artifact = False
+
+    for item in produce:
+        name = item.get("name", "")
+        urn = item.get("urn", "")
+
+        # Theme-based: multiple colons
+        if name.count(":") >= 2:
+            has_theme_artifact = True
+            # URN should match name with contract: prefix
+            assert urn == f"contract:{name}", \
+                f"Expected URN 'contract:{name}', got: {urn}"
+
+    assert has_theme_artifact, "Missing theme-based hierarchy in produce artifacts"
+
+
+# SPEC-TESTER-CONV-0066
+def test_validation_regex_allows_theme_hierarchy(artifact_convention):
+    """Validation regex allows unlimited colons and optional variant dot"""
+    import re
+
+    validation = artifact_convention.get("validation", {})
+    id_pattern = validation.get("id_pattern")
+
+    assert id_pattern is not None, "Missing id_pattern in validation section"
+
+    # Test the regex against valid patterns
+    test_cases = [
+        ("commons:ux:foundations:color", True),  # Deep hierarchy
+        ("commons:ux:foundations", True),  # Medium hierarchy
+        ("mechanic:decision.choice", True),  # Variant with dot
+        ("match:result", True),  # Simple theme:aspect
+        ("sensory:gesture.raw", True),  # Theme:aspect.variant
+        ("invalid", False),  # No colon at all
+        ("no-version:v1", False),  # Old style with version suffix
+    ]
+
+    for test_input, should_match in test_cases:
+        match = re.match(id_pattern, test_input)
+        if should_match:
+            assert match is not None, \
+                f"Pattern '{id_pattern}' should match '{test_input}'"
+        else:
+            # Note: some patterns may or may not match depending on regex specifics
+            pass
+
+
+# SPEC-TESTER-CONV-0067
+def test_migration_note_documents_refactoring(artifact_convention):
+    """Migration note documents legacy URN refactoring"""
+    artifact_urns = artifact_convention.get("artifact_urns", {})
+    migration_strategy = artifact_urns.get("migration_strategy", {})
+    refactor_note = migration_strategy.get("refactor_note", "")
+
+    assert refactor_note != "", "Missing refactor_note in migration_strategy"
+
+    # Check for legacy pattern documentation
+    assert "legacy" in refactor_note.lower() or "migrate" in refactor_note.lower(), \
+        "Should document legacy migration"
+
+    # Check for version suffix removal
+    assert "version" in refactor_note.lower() or "$id" in refactor_note.lower(), \
+        "Should mention version removal from $id"