diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 38be4def60..a1bf019d85 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -317,7 +317,12 @@ repos:
         language: system
         pass_filenames: true
         files: ^src/.*\.py$
-        exclude: ^(tests/|archived/|archive/|scripts/validation/|src/omnibase_core/utils/util_singleton_holders\.py|src/omnibase_core/models/core/model_action_config_value\.py|src/omnibase_core/protocols/).*\.py$
+        # Exclusions:
+        # - protocols/: Protocol types define interfaces, not implementations
+        # - util_singleton_holders.py: Deprecated module with migration docs (no classes, just docstring)
+        # - model_action_config_value.py: Action config value types
+        # - model_node_config_value.py: Node config entry and schema types
+        exclude: ^(tests/|archived/|archive/|scripts/validation/|src/omnibase_core/utils/util_singleton_holders\.py$|src/omnibase_core/models/core/model_action_config_value\.py$|src/omnibase_core/models/configuration/model_node_config_value\.py$|src/omnibase_core/protocols/)
         stages: [pre-commit]
 
       - id: validate-enum-model-imports
diff --git a/.yaml-validation-allowlist.yaml b/.yaml-validation-allowlist.yaml
index 85803b1491..34a12feae2 100644
--- a/.yaml-validation-allowlist.yaml
+++ b/.yaml-validation-allowlist.yaml
@@ -40,6 +40,13 @@ allowed_files:
     added: "2024-10-15"
     review: "2026-06-13"
 
+  - file: "scripts/regenerate_fingerprints.py"
+    reason: "Must parse YAML to detect node_type before selecting appropriate Pydantic model class - contract
+      fingerprint regeneration requires raw YAML to determine which model (ModelContractCompute, ModelContractEffect,
+      etc.) to use for validation via detect_contract_model()"
+    added: "2025-12-12"
+    review: "2026-03-12"
+
 # Specific filenames that are allowed (matched by basename)
 # Allows the same utility to be used across different module paths (e.g., copied utilities)
 allowed_filenames:
diff --git a/contracts/runtime/contract_loader_effect.yaml b/contracts/runtime/contract_loader_effect.yaml
index c479e63cbb..fbc79cc90b 100644
--- a/contracts/runtime/contract_loader_effect.yaml
+++ b/contracts/runtime/contract_loader_effect.yaml
@@ -18,42 +18,17 @@
 # Contract Metadata
 node_type: EFFECT_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:5686d9c0320d"
-
-# Handler requirements for this effect contract
-# Effects perform external I/O and require handlers for their operations
-handlers:
-  required:
-    # Filesystem handler required for directory scanning and file reading operations
-    - type: filesystem
-      version: ">=1.0.0"
-  optional: []
-
-# Kafka topic subscriptions (none for this effect)
-subscriptions:
-  topics: []
-
-# Profile tags for categorization
-profile_tags:
-  - filesystem
-  - contracts
-  - discovery
-  - runtime
-  - loader
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:423f8598810c"
 # Effect Subcontract
 # NOTE: This contract uses `effect_operations` (multi-operation schema) rather than
 # `effect` (single-operation schema) because it defines multiple filesystem operations
 # (scan_contracts_directory, read_contract_file). Contracts with a single operation
 # use the simpler `effect:` key (e.g., event_bus_wiring_effect.yaml).
 effect_operations:
-  version: {major: 1, minor: 0, patch: 0}
-  subcontract_version: {major: 1, minor: 0, patch: 0}
+  version: {major: 1, minor: 1, patch: 0}
+  subcontract_version: {major: 1, minor: 1, patch: 0}
 
   # Execution configuration
   execution_mode: sequential_abort  # Abort on first failure
@@ -228,6 +203,24 @@ effect_operations:
     emit_metrics: true
     trace_propagation: true
 
+# v1.1.0 Required Fields
+handlers:
+  required: []
+  optional:
+    - type: ProtocolLogger
+      version: {major: 1, minor: 0, patch: 0}
+    - type: ProtocolFileSystem
+      version: {major: 1, minor: 0, patch: 0}
+
+profile_tags:
+  - runtime
+  - effect
+  - contracts
+  - discovery
+
+subscriptions:
+  topics: []
+
 # Metadata
 metadata:
   version: {major: 1, minor: 1, patch: 0}
diff --git a/contracts/runtime/contract_registry_reducer.yaml b/contracts/runtime/contract_registry_reducer.yaml
index 737187a3ba..16c5cfc84b 100644
--- a/contracts/runtime/contract_registry_reducer.yaml
+++ b/contracts/runtime/contract_registry_reducer.yaml
@@ -1,22 +1,11 @@
 ---
 node_type: REDUCER_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:6d57709afa44"
-profile_tags:
-  - runtime
-  - contracts
-  - registry
-  - configuration
-handlers:
-  required: []  # Reducers are pure state machines - no external I/O handlers
-  optional: []
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:c753f440fda3"
 state_transitions:
-  version: {major: 1, minor: 1, patch: 0}
+  version: {major: 1, minor: 0, patch: 0}
   state_machine_version: {major: 1, minor: 0, patch: 0}
   state_machine_name: contract_registry_fsm
   description: Maintains state of loaded and compiled ONEX contracts using FSM pattern
@@ -294,6 +283,36 @@ state_transitions:
           trigger: undo_clear
       version: {major: 1, minor: 0, patch: 0}
       operation_type: administrative
+
+# v1.1.0 Required Fields
+# NOTE: The `handlers` section defines protocol-based dependencies injected via DI container.
+# This is SEPARATE from FSM action types (event, logging, data_capture, persistence) which are
+# defined in transition actions.
+#
+# FSM Action Type Execution:
+# The runtime's built-in FSM action executor handles all action_type values. Each action_type
+# maps to a runtime capability:
+#   - event: Publishes events via ProtocolEventBus (optional handler below)
+#   - logging: Logs via ProtocolLogger (optional handler below)
+#   - data_capture: Snapshots state to memory/persistence store
+#   - persistence: Persists FSM state for recovery (when persistence_enabled: true)
+#
+# The `required: []` means no handlers are MANDATORY for this node to function, since the
+# runtime provides default implementations. Optional handlers allow custom implementations.
+handlers:
+  required: []
+  optional:
+    - type: ProtocolLogger
+      version: {major: 1, minor: 0, patch: 0}
+    - type: ProtocolEventBus
+      version: {major: 1, minor: 0, patch: 0}
+
+profile_tags:
+  - runtime
+  - reducer
+  - contracts
+  - registry
+
 metadata:
   version: {major: 1, minor: 1, patch: 0}
   author: ONEX Framework Team
diff --git a/contracts/runtime/event_bus_wiring_effect.yaml b/contracts/runtime/event_bus_wiring_effect.yaml
index abaaaf4ba1..28c477934b 100644
--- a/contracts/runtime/event_bus_wiring_effect.yaml
+++ b/contracts/runtime/event_bus_wiring_effect.yaml
@@ -32,54 +32,16 @@
 # Contract Metadata
 node_type: EFFECT_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:dccda0974f39"
-
-# Handler requirements for this effect contract
-# Effects perform external I/O and require handlers for their operations
-handlers:
-  required:
-    # Local handler required for in-memory event bus wiring operations
-    - type: local
-      version: ">=1.0.0"
-  optional:
-    # Kafka handler optional for distributed event bus deployments
-    - type: kafka
-      version: ">=1.0.0"
-
-# Kafka topic subscriptions for this effect
-# This node subscribes to these topics to receive events for wiring operations
-subscriptions:
-  topics:
-    - topic: onex.runtime.node_graph.ready
-      description: Triggered when node graph is fully instantiated
-      handler: wire_all_subscriptions
-    - topic: onex.runtime.node.registered
-      description: Handle new node registration for hot reload
-      handler: wire_single_subscription
-    - topic: onex.runtime.node.unregistered
-      description: Handle node removal
-      handler: remove_subscription
-
-# Profile tags for categorization
-profile_tags:
-  - runtime
-  - event-bus
-  - subscriptions
-  - self-hosted
-  - wiring
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:5fece4cb7a20"
 # Effect Subcontract
 # NOTE: This contract uses `effect` (single-operation schema) rather than
 # `effect_operations` (multi-operation schema) because it defines a single
 # event bus wiring operation. Contracts with multiple operations use
 # `effect_operations:` with an operations list (e.g., contract_loader_effect.yaml).
 effect:
-  version: {major: 1, minor: 0, patch: 0}
+  version: {major: 1, minor: 1, patch: 0}
 
   # Operation identification
   operation_name: event_bus_wiring
@@ -246,6 +208,31 @@ health_check:
       critical: false
       threshold_ms: 1000
 
+# Event subscriptions (what this node listens to)
+# NOTE: Each subscription defines a `handler` field that references a method that MUST be
+# implemented by the runtime or node implementation. These handlers are NOT protocol-based
+# dependencies (those go in the `handlers` section below). Instead, subscription handlers
+# are callback methods that the event bus invokes when matching events arrive.
+#
+# Handler Implementation Requirements:
+# - wire_all_subscriptions: Receives ModelNodeGraphReadyEvent, wires all nodes to their subscriptions
+# - wire_single_subscription: Receives ModelNodeRegisteredEvent, wires a single new node
+# - remove_subscription: Receives ModelNodeUnregisteredEvent, removes subscription for a node
+#
+# These handlers are implemented by the NodeEventBusWiringEffect class or provided by the
+# runtime's built-in subscription handler executor. See docs/architecture/SUBSCRIPTION_HANDLERS.md.
+subscriptions:
+  topics:
+    - topic: onex.runtime.node_graph.ready
+      description: Triggered when node graph is fully instantiated
+      handler: wire_all_subscriptions
+    - topic: onex.runtime.node.registered
+      description: Handle new node registration for hot reload
+      handler: wire_single_subscription
+    - topic: onex.runtime.node.unregistered
+      description: Handle node removal
+      handler: remove_subscription
+
 # Events published by this node
 publications:
   - topic: onex.runtime.ready
@@ -261,6 +248,21 @@ publications:
     description: Wiring encountered a critical error
     payload_schema: ModelWiringErrorEvent
 
+# v1.1.0 Required Fields
+handlers:
+  required:
+    - type: ProtocolEventBus
+      version: {major: 1, minor: 0, patch: 0}
+  optional:
+    - type: ProtocolLogger
+      version: {major: 1, minor: 0, patch: 0}
+
+profile_tags:
+  - runtime
+  - effect
+  - event-bus
+  - wiring
+
 # Metadata
 metadata:
   version: {major: 1, minor: 1, patch: 0}
diff --git a/contracts/runtime/node_graph_reducer.yaml b/contracts/runtime/node_graph_reducer.yaml
index a4c7c189e5..9eee84addd 100644
--- a/contracts/runtime/node_graph_reducer.yaml
+++ b/contracts/runtime/node_graph_reducer.yaml
@@ -1,22 +1,15 @@
 ---
 node_type: REDUCER_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:6cc216f5b6d9"
-profile_tags:
-  - runtime
-  - node-graph
-  - lifecycle
-  - infrastructure
-handlers:
-  required: []  # Reducers are pure state machines - no external I/O handlers
-  optional: []
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:a4f95b414375"
 state_transitions:
-  version: {major: 1, minor: 1, patch: 0}
+  # NOTE: FSM version (1.0.0) intentionally differs from contract_version (1.1.0).
+  # The contract version tracks overall contract changes (handlers, metadata, profile_tags),
+  # while the FSM version only increments when states, transitions, or conditions change.
+  # This separation allows metadata updates without implying FSM structural changes.
+  version: {major: 1, minor: 0, patch: 0}
   state_machine_version: {major: 1, minor: 0, patch: 0}
   state_machine_name: node_graph_fsm
   description: Maintains instantiated node graph state with FSM-driven lifecycle management
@@ -304,6 +297,38 @@ state_transitions:
           trigger: undo_rewire
       version: {major: 1, minor: 0, patch: 0}
       operation_type: administrative
+
+# v1.1.0 Required Fields
+# NOTE: The `handlers` section defines protocol-based dependencies injected via DI container.
+# This is SEPARATE from FSM action types (event, logging, data_capture, persistence, alert, cleanup)
+# which are defined in transition actions.
+#
+# FSM Action Type Execution:
+# The runtime's built-in FSM action executor handles all action_type values. Each action_type
+# maps to a runtime capability:
+#   - event: Publishes events via ProtocolEventBus (optional handler below)
+#   - logging: Logs via ProtocolLogger (optional handler below)
+#   - data_capture: Snapshots state to memory/persistence store
+#   - persistence: Persists FSM state for recovery (when persistence_enabled: true)
+#   - alert: Emits alerts via alerting subsystem (monitoring integration)
+#   - cleanup: Executes resource cleanup procedures
+#
+# The `required: []` means no handlers are MANDATORY for this node to function, since the
+# runtime provides default implementations. Optional handlers allow custom implementations.
+handlers:
+  required: []
+  optional:
+    - type: ProtocolLogger
+      version: {major: 1, minor: 0, patch: 0}
+    - type: ProtocolEventBus
+      version: {major: 1, minor: 0, patch: 0}
+
+profile_tags:
+  - runtime
+  - reducer
+  - node-graph
+  - lifecycle
+
 metadata:
   version: {major: 1, minor: 1, patch: 0}
   author: ONEX Framework Team
diff --git a/contracts/runtime/runtime_orchestrator.yaml b/contracts/runtime/runtime_orchestrator.yaml
index 12b1162317..86807371c9 100644
--- a/contracts/runtime/runtime_orchestrator.yaml
+++ b/contracts/runtime/runtime_orchestrator.yaml
@@ -50,51 +50,14 @@
 # Contract Metadata
 node_type: ORCHESTRATOR_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:3e52c90d2a6f"
-
-# Profile tags for runtime orchestrator classification
-profile_tags:
-  - runtime
-  - kernel
-  - self-hosted
-  - lifecycle-management
-
-# Handlers configuration
-handlers:
-  required: []  # Orchestrators coordinate, may not need direct handlers
-  optional:
-    - type: local
-      version: ">=1.0.0"
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:33154c46968c"
 # Workflow Coordination Subcontract
 workflow_coordination:
   version: {major: 1, minor: 1, patch: 0}
   subcontract_version: {major: 1, minor: 1, patch: 0}
 
-  # Workflow Steps: Required step definitions for runtime orchestration
-  workflow_steps:
-    - step_id: "contract_loader"
-      step_name: "Contract Loader"
-      step_type: "effect"
-      depends_on: []
-    - step_id: "contract_registry"
-      step_name: "Contract Registry"
-      step_type: "reducer"
-      depends_on: ["contract_loader"]
-    - step_id: "node_graph"
-      step_name: "Node Graph Manager"
-      step_type: "reducer"
-      depends_on: ["contract_registry"]
-    - step_id: "event_bus_wiring"
-      step_name: "Event Bus Wiring"
-      step_type: "effect"
-      depends_on: ["node_graph"]
-
   # Workflow Definition: Runtime lifecycle management
   workflow_definition:
     # Workflow Metadata
@@ -502,6 +465,21 @@ performance_benchmarks:
     warning_multiplier: 1.5  # Flag if 50% slower than target
     critical_multiplier: 2.0  # Fail if 2x slower than target
 
+# v1.1.0 Required Fields
+handlers:
+  required:
+    - type: ProtocolEventBus
+      version: {major: 1, minor: 0, patch: 0}
+  optional:
+    - type: ProtocolLogger
+      version: {major: 1, minor: 0, patch: 0}
+
+profile_tags:
+  - runtime
+  - orchestrator
+  - kernel
+  - lifecycle
+
 # Metadata
 metadata:
   version: {major: 1, minor: 1, patch: 0}
diff --git a/docs/conventions/NAMING_CONVENTIONS.md b/docs/conventions/NAMING_CONVENTIONS.md
new file mode 100644
index 0000000000..3328f1c6b3
--- /dev/null
+++ b/docs/conventions/NAMING_CONVENTIONS.md
@@ -0,0 +1,474 @@
+# ONEX Naming Conventions
+
+This document defines naming conventions for ONEX components including topics, handlers, profiles, subscriptions, and fingerprints.
+
+---
+
+## Table of Contents
+
+1. [Topic Naming](#topic-naming)
+2. [Handler Conventions](#handler-conventions)
+3. [Profile Tags](#profile-tags)
+4. [Subscription Formats](#subscription-formats)
+5. [Fingerprint Format](#fingerprint-format)
+6. [Model Naming](#model-naming)
+
+---
+
+## Topic Naming
+
+### Required Prefix: `onex.*`
+
+All ONEX event bus topics **MUST** use the `onex.` prefix to:
+- Ensure namespace isolation from other systems
+- Enable topic filtering and routing
+- Support multi-tenant deployments
+- Provide clear ownership and discoverability
+
+### Topic Format
+
+Topics and event types follow a hierarchical naming structure:
+
+- **Topic name**: The full dot-separated path used for event bus routing (e.g., `onex.node.compute.completed`). This is what you subscribe to or publish on.
+- **Event type suffix**: The final segment that describes what happened (e.g., `completed`, `failed`, `started`). This is part of the topic name, not a separate identifier.
+
+```text
+onex.<domain>.<entity>.<event-type-suffix>
+```
+
+**Components:**
+- `onex.` - Required prefix (lowercase)
+- `<domain>` - Business domain (e.g., `node`, `workflow`, `discovery`)
+- `<entity>` - Specific entity type (e.g., `compute`, `effect`, `reducer`)
+- `<event-type-suffix>` - Event action suffix (e.g., `created`, `completed`, `failed`)
+
+### Examples
+
+```python
+# Node lifecycle events
+"onex.node.compute.started"
+"onex.node.compute.completed"
+"onex.node.effect.failed"
+
+# Workflow events
+"onex.workflow.execution.started"
+"onex.workflow.step.completed"
+"onex.workflow.execution.failed"
+
+# Discovery events
+"onex.discovery.request"
+"onex.discovery.response"
+"onex.introspection.request"
+"onex.introspection.response"
+
+# System events (use reserved topic prefixes from table below)
+"onex.discovery.node.request"
+"onex.introspection.node.request"
+"onex.health.node.check"
+"onex.metrics.node.collected"
+"onex.dlq.compute.failed"
+```
+
+### Reserved Topics
+
+These topics are reserved for ONEX core functionality:
+
+| Topic | Purpose |
+|-------|---------|
+| `onex.discovery.*` | Node discovery protocol |
+| `onex.introspection.*` | Node introspection protocol |
+| `onex.health.*` | Health check protocol |
+| `onex.metrics.*` | Metrics collection |
+| `onex.dlq.*` | Dead letter queues |
+
+### Topic Configuration
+
+```python
+from omnibase_core.models.configuration.model_event_bus_config import (
+    ModelEventBusConfig,
+)
+
+config = ModelEventBusConfig(
+    bootstrap_servers=["localhost:9092"],
+    topics=[
+        "onex.node.compute.events",  # Correct: uses onex. prefix
+        "onex.workflow.execution.events",
+    ],
+    # ... other configuration
+)
+```
+
+---
+
+## Handler Conventions
+
+### Handler Type Classification
+
+Handlers are classified by `EnumHandlerType` for routing purposes:
+
+| Handler Type | Purpose | Example |
+|-------------|---------|---------|
+| `HTTP` | HTTP/REST API calls | API gateway, webhooks |
+| `DATABASE` | Database operations | PostgreSQL, MongoDB queries |
+| `KAFKA` | Message queue operations | Event publishing/consuming |
+| `FILESYSTEM` | File system operations | File read/write, temp files |
+| `GRPC` | gRPC service calls | Microservice communication |
+| `WEBSOCKET` | WebSocket connections | Real-time streaming |
+| `CUSTOM` | Custom implementations | Specialized handlers |
+
+### When Handlers are Required vs Optional
+
+**Required Handlers:**
+- Node contracts that specify `io_configs` **MUST** have registered handlers for each I/O type
+- Runtime will fail on initialization if required handlers are missing
+- Example: A contract specifying `HTTP` I/O requires an HTTP handler
+
+**Optional Handlers:**
+- Handlers can be registered dynamically at runtime
+- Handlers can be replaced (same `handler_type` overwrites previous)
+- Use `replace=False` for strict registration that raises on duplicates
+
+### Handler Registration Example
+
+```python
+"""Example handler implementation demonstrating ONEX conventions.
+
+Copy-paste safe: All imports and types are included.
+"""
+
+from omnibase_core.enums.enum_handler_type import EnumHandlerType
+from omnibase_core.models.core.model_onex_envelope import ModelOnexEnvelope
+from omnibase_core.models.primitives.model_semver import ModelSemVer
+from omnibase_core.protocols.runtime import ProtocolHandler
+from omnibase_core.types.typed_dict_handler_metadata import TypedDictHandlerMetadata
+
+
+class MyHttpHandler(ProtocolHandler):
+    """Custom HTTP handler implementation.
+
+    This handler processes HTTP-related events through the ONEX event bus.
+    Implements the ProtocolHandler interface for runtime integration.
+    """
+
+    @property
+    def handler_type(self) -> EnumHandlerType:
+        """Return the handler type classification."""
+        return EnumHandlerType.HTTP
+
+    async def execute(self, envelope: ModelOnexEnvelope) -> ModelOnexEnvelope:
+        """Execute the handler logic.
+
+        Args:
+            envelope: The incoming event envelope to process.
+
+        Returns:
+            The processed event envelope with results.
+        """
+        # Implement your handler logic here
+        # Example: Process HTTP request data from envelope.payload
+        return envelope
+
+    def describe(self) -> TypedDictHandlerMetadata:
+        """Provide handler metadata for discovery and routing.
+
+        Returns:
+            Handler metadata dictionary with name, version, and capabilities.
+        """
+        return {
+            "name": "my_http_handler",
+            "version": ModelSemVer(major=1, minor=0, patch=0),
+            "description": "Custom HTTP handler for API integration",
+            "capabilities": ["GET", "POST", "PUT", "DELETE"],
+        }
+```
+
+### Handler Version Format
+
+Handler versions **MUST** use semantic versioning (SemVer):
+
+```python
+from omnibase_core.models.primitives.model_semver import ModelSemVer
+
+version = ModelSemVer(major=1, minor=0, patch=0)  # 1.0.0
+```
+
+**Version Compatibility:**
+- Major version change: Breaking API changes
+- Minor version change: Backward-compatible features
+- Patch version change: Bug fixes only
+
+---
+
+## Profile Tags
+
+### Tag Formats
+
+Profile tags support two formats:
+
+#### 1. Hierarchical Format (Recommended for Metadata)
+
+Use `category:value` format for structured metadata that supports filtering:
+
+```text
+<category>:<value>
+```
+
+#### 2. Simple String Format (For Categorization)
+
+Use simple strings without colons for basic categorization tags:
+
+```text
+<tag-name>
+```
+
+### Standard Hierarchical Categories
+
+| Category | Purpose | Examples |
+|----------|---------|----------|
+| `env` | Environment classification | `env:production`, `env:staging`, `env:development` |
+| `region` | Geographic region | `region:us-east-1`, `region:eu-west-1` |
+| `tier` | Service tier | `tier:critical`, `tier:standard`, `tier:background` |
+| `team` | Owning team | `team:platform`, `team:data`, `team:ml` |
+| `capability` | Feature capabilities | `capability:async`, `capability:batch` |
+
+### Common Simple Tags
+
+Simple tags are useful for categorization without structured filtering:
+
+| Tag | Purpose |
+|-----|---------|
+| `runtime` | Runtime-related functionality |
+| `effect` | Effect node functionality |
+| `contracts` | Contract-related functionality |
+| `validation` | Validation functionality |
+| `discovery` | Discovery-related functionality |
+
+### Tag Usage in Python
+
+```python
+from omnibase_core.models.container.model_service_metadata import (
+    ModelServiceMetadata,
+)
+
+metadata = ModelServiceMetadata(
+    service_id=uuid4(),
+    service_name="compute_processor",
+    service_interface="ProtocolCompute",
+    service_implementation="ComputeProcessor",
+    version=ModelSemVer(major=1, minor=0, patch=0),
+    tags=[
+        # Hierarchical tags for filtering
+        "env:production",
+        "tier:critical",
+        "team:platform",
+        "capability:async",
+    ],
+)
+```
+
+### Tag Usage in YAML Contracts
+
+Both formats are valid in YAML `profile_tags` arrays:
+
+```yaml
+# Example with hierarchical tags
+profile_tags:
+  - "env:production"
+  - "tier:critical"
+  - "team:platform"
+
+# Example with simple categorization tags
+profile_tags:
+  - "runtime"
+  - "effect"
+  - "contracts"
+
+# Mixed usage (valid but hierarchical preferred for consistency)
+profile_tags:
+  - "env:production"
+  - "runtime"
+```
+
+### Tag Best Practices
+
+1. **Lowercase**: Use lowercase for consistency
+2. **Hierarchical for Filtering**: Use `category:value` format when you need to filter by category
+3. **Simple for Categorization**: Use simple strings for basic categorization without filtering needs
+4. **Consistent Within Project**: Choose one format per use case and apply consistently
+5. **Documented**: Document custom tags in your project
+
+---
+
+## Subscription Formats
+
+### Event Subscription Patterns
+
+Subscriptions use pattern matching for flexible event filtering:
+
+```python
+subscribed_events: list[str] = [
+    "NODE_INTROSPECTION_REQUEST",  # Exact match
+    "NODE_DISCOVERY_REQUEST",      # Exact match
+    "WORKFLOW_*",                  # Wildcard: all WORKFLOW events
+]
+```
+
+### Pattern Types
+
+| Pattern | Description | Example |
+|---------|-------------|---------|
+| Exact | Matches exact event type | `NODE_INTROSPECTION_REQUEST` |
+| Wildcard suffix | Matches prefix with any suffix | `WORKFLOW_*` |
+| Wildcard prefix | Matches suffix with any prefix | `*_COMPLETED` |
+
+### Filter Configuration
+
+```python
+from omnibase_core.models.contracts.subcontracts.model_event_handling_subcontract import (
+    ModelEventHandlingSubcontract,
+)
+
+event_handling = ModelEventHandlingSubcontract(
+    version=ModelSemVer(major=1, minor=0, patch=0),
+    enabled=True,
+    subscribed_events=[
+        "NODE_INTROSPECTION_REQUEST",
+        "NODE_DISCOVERY_REQUEST",
+    ],
+    event_filters={
+        "node_id": "compute-*",   # fnmatch pattern
+        "node_name": "processor*",
+    },
+    enable_node_id_filtering=True,
+    enable_node_name_filtering=True,
+)
+```
+
+### Dead Letter Queue Configuration
+
+Failed events can be routed to a dead letter queue:
+
+```python
+event_handling = ModelEventHandlingSubcontract(
+    # ... other config ...
+    dead_letter_channel="onex.dlq.compute.failed",  # Must be alphanumeric with ._-
+    dead_letter_max_events=1000,
+    dead_letter_overflow_strategy="drop_oldest",  # or "drop_newest", "block"
+)
+```
+
+---
+
+## Fingerprint Format
+
+### Format Specification
+
+```text
+<semver>:<sha256-first-N-hex-chars>
+```
+
+**Components:**
+- `semver`: Semantic version **without 'v' prefix** (e.g., `1.0.0`, `0.4.0-beta.1`)
+- `:`: Separator (single colon)
+- `hash`: First N hex characters of SHA256 (default: 12)
+
+**Important:** The semver component must NOT include a 'v' prefix. Use `1.0.0`, not `v1.0.0`.
+
+### Examples
+
+```text
+1.0.0:8fa1e2b4c9d1
+0.4.0:abcdef123456
+2.1.3-beta.1:deadbeef0000
+```
+
+### Hash Length Configuration
+
+Default hash length is **12 characters (48 bits)**.
+
+**Collision Analysis:**
+- 12 chars = 48 bits = ~281 trillion possibilities
+- With 10,000 contracts: ~0.00002% collision probability
+- Sufficient for typical contract registries
+
+**Configure longer hash for higher security:**
+
+```python
+from omnibase_core.models.contracts.model_contract_normalization_config import (
+    ModelContractNormalizationConfig,
+)
+
+config = ModelContractNormalizationConfig(
+    hash_length=16,  # 64 bits for higher security
+)
+```
+
+### Fingerprint Computation
+
+```python
+from omnibase_core.contracts.hash_registry import compute_contract_fingerprint
+
+# Compute fingerprint for a contract model
+fingerprint = compute_contract_fingerprint(contract_model)
+print(fingerprint)  # "1.0.0:8fa1e2b4c9d1"
+```
+
+---
+
+## Model Naming
+
+### Model Class Naming
+
+All Pydantic model classes **MUST** use the `Model` prefix:
+
+```python
+# Correct
+class ModelComputeInput(BaseModel): ...
+class ModelEffectOutput(BaseModel): ...
+class ModelContractFingerprint(BaseModel): ...
+
+# Incorrect
+class ComputeInput(BaseModel): ...
+class EffectOutput(BaseModel): ...
+```
+
+### Contract Naming
+
+Contract names should follow PascalCase or snake_case:
+
+```yaml
+# PascalCase (recommended for node contracts)
+name: NodeDataTransformerCompute
+
+# snake_case (acceptable)
+name: node_data_transformer_compute
+```
+
+### File Naming
+
+Model files follow `model_<name>.py` convention:
+
+```text
+models/
+  core/
+    model_onex_envelope.py
+    model_event_channels.py
+  contracts/
+    model_contract_compute.py
+    model_contract_fingerprint.py
+```
+
+---
+
+## Related Documentation
+
+- **Pydantic Best Practices**: `docs/conventions/PYDANTIC_BEST_PRACTICES.md`
+- **Version Semantics**: `docs/conventions/VERSION_SEMANTICS.md`
+- **Error Handling**: `docs/conventions/ERROR_HANDLING_BEST_PRACTICES.md`
+- **Contract System**: `docs/architecture/CONTRACT_SYSTEM.md`
+- **Event-Driven Architecture**: `docs/patterns/EVENT_DRIVEN_ARCHITECTURE.md`
+
+---
+
+**Last Updated**: 2025-12-12
+**Project**: omnibase_core v0.4.0
diff --git a/docs/conventions/PYDANTIC_BEST_PRACTICES.md b/docs/conventions/PYDANTIC_BEST_PRACTICES.md
new file mode 100644
index 0000000000..e3145ea057
--- /dev/null
+++ b/docs/conventions/PYDANTIC_BEST_PRACTICES.md
@@ -0,0 +1,364 @@
+# Pydantic Best Practices for ONEX
+
+This document covers Pydantic configuration patterns, safety considerations, and best practices for ONEX models.
+
+---
+
+## Table of Contents
+
+1. [Model Configuration](#model-configuration)
+2. [from_attributes Safety](#from_attributes-safety)
+3. [Frozen Models](#frozen-models)
+4. [Validation Patterns](#validation-patterns)
+5. [Error Handling](#error-handling)
+
+---
+
+## Model Configuration
+
+### Standard ConfigDict Options
+
+```python
+from pydantic import BaseModel, ConfigDict
+
+class ModelExample(BaseModel):
+    model_config = ConfigDict(
+        frozen=True,           # Immutable after creation
+        extra="forbid",        # Reject unknown fields
+        validate_assignment=True,  # Validate on attribute assignment
+    )
+```
+
+### Common Configuration Patterns
+
+| Option | Value | Use Case |
+|--------|-------|----------|
+| `frozen=True` | Immutable model | Fingerprints, envelopes, security models |
+| `frozen=False` | Mutable model | Configuration, builders, state objects |
+| `extra="forbid"` | Strict validation | Contracts, security models |
+| `extra="ignore"` | Flexible input | YAML contracts, external data |
+| `validate_assignment=True` | Re-validate on set | Mutable models with constraints |
+
+---
+
+## from_attributes Safety
+
+### What is `from_attributes`?
+
+The `from_attributes=True` config option allows Pydantic to create models from arbitrary objects by reading their attributes:
+
+```python
+class ModelServiceMetadata(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    name: str
+    version: str
+
+# Can create from any object with .name and .version attributes
+class SomeOtherClass:
+    name = "service"
+    version = "1.0.0"
+
+metadata = ModelServiceMetadata.model_validate(SomeOtherClass())
+```
+
+### When `from_attributes` is Safe
+
+**SAFE - Frozen/Immutable Source Models:**
+
+```python
+from pydantic import BaseModel, ConfigDict
+
+class ModelContractFingerprint(BaseModel):
+    """Immutable fingerprint - safe for from_attributes."""
+    model_config = ConfigDict(
+        frozen=True,           # IMMUTABLE
+        from_attributes=True,  # Safe because frozen
+    )
+
+    version: str
+    hash_prefix: str
+```
+
+**Why it's safe:**
+- Source object cannot be modified after creation
+- No race conditions during attribute access
+- Predictable behavior in concurrent scenarios
+
+### When `from_attributes` is Risky
+
+**RISKY - Mutable Source Objects:**
+
+```python
+# CAUTION: Mutable object with from_attributes
+class ModelMutableConfig(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    timeout: int
+    retries: int
+
+# Race condition risk:
+config_obj = MutableConfigObject()
+# Thread 1: config_obj.timeout = 30
+# Thread 2: model = ModelMutableConfig.model_validate(config_obj)
+# Thread 1: config_obj.timeout = 60
+# What value did Thread 2 get?
+```
+
+### Safety Guidelines
+
+| Source Type | `from_attributes` | Safety Level |
+|-------------|-------------------|--------------|
+| Frozen Pydantic model | Safe | Use freely |
+| Immutable dataclass (`frozen=True`) | Safe | Use freely |
+| NamedTuple | Safe | Use freely |
+| Regular class (mutable) | Risky | Add synchronization |
+| Dict-like objects | Safe | Pydantic handles dict input |
+
+### Recommended Pattern
+
+**For thread-safe models that use `from_attributes`:**
+
+```python
+from pydantic import BaseModel, ConfigDict
+
+class ModelServiceMetadata(BaseModel):
+    """
+    Service registration metadata.
+
+    Thread Safety:
+        This model uses `from_attributes=True` for ORM compatibility.
+        It is safe to use because:
+        1. Source objects should be frozen/immutable when possible
+        2. If mutable, ensure single-writer access during model creation
+        3. The created Pydantic model is independent of the source object
+    """
+    model_config = ConfigDict(from_attributes=True)
+
+    service_id: UUID
+    service_name: str
+    version: ModelSemVer
+```
+
+**For models that MUST be immutable:**
+
+```python
+class ModelContractFingerprint(BaseModel):
+    """
+    Contract fingerprint for integrity verification.
+
+    Immutability Guarantee:
+        This model is frozen (immutable) after creation to ensure:
+        1. Thread-safe access from multiple readers
+        2. Safe use as dictionary keys
+        3. No accidental modification of computed fingerprints
+    """
+    model_config = ConfigDict(
+        frozen=True,
+        extra="forbid",
+        validate_assignment=True,
+    )
+
+    version: ModelContractVersion
+    hash_prefix: str
+    full_hash: str
+```
+
+---
+
+## Frozen Models
+
+### When to Use `frozen=True`
+
+**Use frozen models for:**
+
+1. **Fingerprints and Hashes** - Integrity verification requires immutability
+2. **Envelope Metadata** - Event routing must not change mid-processing
+3. **Security Context** - Authentication/authorization data
+4. **Configuration Snapshots** - Point-in-time configuration capture
+5. **Cache Keys** - Hashable objects for dictionary keys
+
+### Frozen Model Benefits
+
+```python
+from pydantic import BaseModel, ConfigDict
+
+class ModelImmutableConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    name: str
+    value: int
+
+# Benefits:
+config = ModelImmutableConfig(name="test", value=42)
+
+# 1. Thread-safe reads (no writes possible)
+# Multiple threads can read without synchronization
+
+# 2. Hashable (usable as dict key)
+cache: dict[ModelImmutableConfig, str] = {}
+cache[config] = "cached_result"
+
+# 3. Prevents accidental modification
+config.name = "new"  # Raises ValidationError
+```
+
+### Frozen Model Limitations
+
+```python
+# Cannot modify after creation
+config.name = "new"  # ValidationError!
+
+# Cannot use mutable defaults
+class ModelBadDefault(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    items: list[str] = []  # WARNING: shared mutable default
+
+# Correct: use default_factory
+class ModelGoodDefault(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    items: list[str] = Field(default_factory=list)
+```
+
+---
+
+## Validation Patterns
+
+### Field Validators
+
+```python
+from pydantic import BaseModel, Field, field_validator
+
+class ModelEventConfig(BaseModel):
+    topic: str = Field(..., description="Event topic name")
+
+    @field_validator("topic")
+    @classmethod
+    def validate_topic_prefix(cls, v: str) -> str:
+        """Ensure topic uses onex.* prefix."""
+        if not v.startswith("onex."):
+            raise ValueError(f"Topic must start with 'onex.', got '{v}'")
+        return v
+```
+
+### Model Validators
+
+```python
+from pydantic import BaseModel, model_validator
+
+class ModelRetryConfig(BaseModel):
+    max_retries: int
+    retry_delay: float
+
+    @model_validator(mode="after")
+    def validate_retry_config(self) -> "ModelRetryConfig":
+        """Validate retry configuration consistency."""
+        if self.max_retries > 0 and self.retry_delay <= 0:
+            raise ValueError("retry_delay must be > 0 when max_retries > 0")
+        return self
+```
+
+### Custom Error Messages
+
+```python
+from omnibase_core.models.errors.model_onex_error import ModelOnexError
+from omnibase_core.enums.enum_core_error_code import EnumCoreErrorCode
+
+@field_validator("channel_name")
+@classmethod
+def validate_channel_name(cls, v: str) -> str:
+    """Validate channel name format."""
+    if not v.replace("_", "").replace(".", "").replace("-", "").isalnum():
+        raise ModelOnexError(
+            message=f"Channel name must be alphanumeric with ._-, got '{v}'",
+            error_code=EnumCoreErrorCode.VALIDATION_ERROR,
+            field="channel_name",
+            provided_value=v,
+        )
+    return v
+```
+
+---
+
+## Error Handling
+
+### ONEX Error Integration
+
+Always use `ModelOnexError` instead of generic exceptions:
+
+```python
+from omnibase_core.models.errors.model_onex_error import ModelOnexError
+from omnibase_core.enums.enum_core_error_code import EnumCoreErrorCode
+
+class ModelContractFingerprint(BaseModel):
+    @classmethod
+    def from_string(cls, fingerprint_str: str) -> "ModelContractFingerprint":
+        if ":" not in fingerprint_str:
+            raise ModelOnexError(
+                message=f"Invalid fingerprint format: '{fingerprint_str}'",
+                error_code=EnumCoreErrorCode.VALIDATION_ERROR,
+                fingerprint=fingerprint_str,
+                expected_format="<semver>:<hash>",
+            )
+        # ... parsing logic
+```
+
+### Validation Error Context
+
+Provide rich context for debugging:
+
+```python
+@model_validator(mode="after")
+def validate_configuration(self) -> "ModelConfig":
+    if not self.async_support and not self.sync_fallback:
+        raise ModelOnexError(
+            message="At least one of async_support or sync_fallback must be enabled",
+            error_code=EnumCoreErrorCode.VALIDATION_ERROR,
+            details=ModelErrorContext.with_context({
+                "async_support": ModelSchemaValue.from_value(self.async_support),
+                "sync_fallback": ModelSchemaValue.from_value(self.sync_fallback),
+            }),
+        )
+    return self
+```
+
+---
+
+## Quick Reference
+
+### Model Configuration Checklist
+
+| Model Type | frozen | extra | from_attributes | validate_assignment |
+|------------|--------|-------|-----------------|---------------------|
+| Fingerprint | `True` | `"forbid"` | Optional | `True` |
+| Envelope | `True` | `"forbid"` | Optional | `True` |
+| Contract | `False` | `"ignore"` | No | `True` |
+| Config | `False` | `"forbid"` | Optional | `True` |
+| Metadata | `False` | (default) | `True` (ORM) | (default) |
+
+**Note**: Metadata models use `from_attributes=True` for ORM compatibility. Other options
+use Pydantic defaults unless specific validation behavior is required.
+
+### Safety Decision Tree
+
+```plaintext
+Need from_attributes?
+├── No → Don't enable it
+└── Yes → Is source object immutable?
+    ├── Yes (frozen Pydantic, NamedTuple) → Safe to use
+    └── No (mutable class) → Add synchronization or copy first
+```
+
+---
+
+## Related Documentation
+
+- **Naming Conventions**: `docs/conventions/NAMING_CONVENTIONS.md`
+- **Error Handling**: `docs/conventions/ERROR_HANDLING_BEST_PRACTICES.md`
+- **Threading Guide**: `docs/guides/THREADING.md`
+- **Contract System**: `docs/architecture/CONTRACT_SYSTEM.md`
+
+---
+
+**Last Updated**: 2025-12-12
+**Project**: omnibase_core v0.4.0
diff --git a/examples/contracts/compute/user_profile_normalizer.yaml b/examples/contracts/compute/user_profile_normalizer.yaml
index 6945c7f6a7..6bd10b2c16 100644
--- a/examples/contracts/compute/user_profile_normalizer.yaml
+++ b/examples/contracts/compute/user_profile_normalizer.yaml
@@ -1,7 +1,7 @@
 ---
 # Example: Contract-Driven NodeCompute Pipeline - User Profile Normalizer
 #
-# This example demonstrates the v1.0 NodeCompute contract-driven pipeline system
+# This example demonstrates the v1.1.0 NodeCompute contract-driven pipeline system
 # for normalizing user profile data before storage or processing.
 #
 # USE CASE: Normalize user-submitted profile data to ensure consistency:
@@ -29,49 +29,9 @@
 # Contract required fields
 node_type: COMPUTE_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:15c395cb78d1"
-
-# ---------------------------------------------------------------------------
-# CONCURRENCY SEMANTICS
-# ---------------------------------------------------------------------------
-# concurrency: parallelizable | sequential
-#
-# "parallelizable" means this COMPUTE node instance can be safely executed
-# in parallel with OTHER node instances (horizontal scaling). The runtime
-# may spawn multiple instances of this node to process different inputs
-# concurrently. This is safe because COMPUTE nodes are pure transformations
-# with no shared mutable state or external I/O.
-#
-# This is DIFFERENT from pipeline step execution:
-# - Pipeline steps within this contract ALWAYS execute sequentially
-#   (abort-on-first-failure semantics, see compute.pipeline below)
-# - "parallelizable" refers to node-level parallelism, not step-level
-#
-# Use "sequential" if the node has singleton constraints or requires
-# exclusive access to in-memory caches that cannot be shared.
-#
-# For most COMPUTE nodes, "parallelizable" is the correct choice because:
-# 1. No external I/O (handled by EFFECT nodes)
-# 2. No shared mutable state (pure transformations)
-# 3. Deterministic output for given input
-concurrency: parallelizable
-
-profile_tags:
-  - compute
-  - transformation
-  - user-data
-
-# Handler requirements for this compute contract
-# COMPUTE nodes are pure transformations - no external I/O handlers required
-handlers:
-  required: []
-  optional: []
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:8d515de74de2"
 # ---------------------------------------------------------------------------
 # COMPUTE SUBCONTRACT: Defines the transformation pipeline
 # ---------------------------------------------------------------------------
@@ -81,11 +41,11 @@ handlers:
 
 compute:
   # Schema version for forward compatibility
-  version: {major: 1, minor: 0, patch: 0}
+  version: {major: 1, minor: 1, patch: 0}
 
   # Operation identification
   operation_name: user_profile_normalizer
-  operation_version: {major: 1, minor: 0, patch: 0}
+  operation_version: {major: 1, minor: 1, patch: 0}
   description: |
     Normalizes user profile data for consistent storage and processing.
     Handles unicode normalization, whitespace trimming, email standardization,
diff --git a/examples/contracts/effect/db_query.yaml b/examples/contracts/effect/db_query.yaml
index fe898674fc..64fb7192a3 100644
--- a/examples/contracts/effect/db_query.yaml
+++ b/examples/contracts/effect/db_query.yaml
@@ -52,7 +52,7 @@
 #
 # 📚 For comprehensive security guidance, see: SECURITY.md in this directory
 #
-# v1.1.0 Contract Schema Version
+# v1.0 Contract Schema Version
 # ============================================================================
 
 # ---------------------------------------------------------------------------
@@ -63,40 +63,18 @@ contract_version:
   major: 1
   minor: 1
   patch: 0
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:63026d0ac547"
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:2bfccb1a6f3f"
 node_type: effect
 
-# Handler requirements for this effect contract
-handlers:
-  required:
-    - type: db
-      version: ">=1.0.0"
-  optional: []
-
-# Kafka topic subscriptions (none for this effect)
-subscriptions:
-  topics: []
-
-# Profile tags for categorization
-profile_tags:
-  - database
-  - sql
-  - postgresql
-  - user-management
-
 # ---------------------------------------------------------------------------
 # EFFECT SUBCONTRACT: Defines database operations
 # ---------------------------------------------------------------------------
 
 effect_operations:
   # Schema version for forward compatibility - must use dict format for ModelSemVer
-  version: {major: 1, minor: 0, patch: 0}
+  version: {major: 1, minor: 1, patch: 0}
 
   # Unique subcontract name (required by ModelEffectSubcontract)
   subcontract_name: "db_query_effect"
diff --git a/examples/contracts/effect/filesystem_operations.yaml b/examples/contracts/effect/filesystem_operations.yaml
index 7656ad361f..12879e7d93 100644
--- a/examples/contracts/effect/filesystem_operations.yaml
+++ b/examples/contracts/effect/filesystem_operations.yaml
@@ -65,40 +65,20 @@ contract_version:
   major: 1
   minor: 1
   patch: 0
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:1e8106221a03"
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "v1.1.0:920b41e8af2f"
 node_type: effect
 
-# Handler requirements for this effect contract
-handlers:
-  required:
-    - type: filesystem
-      version: ">=1.0.0"
-  optional: []
-
-# Kafka topic subscriptions (none for this effect)
-subscriptions:
-  topics: []
-
-# Profile tags for categorization
-profile_tags:
-  - filesystem
-  - file-operations
-  - document-management
-  - storage
-
 # ---------------------------------------------------------------------------
 # EFFECT SUBCONTRACT: Defines filesystem operations
 # ---------------------------------------------------------------------------
 
 effect_operations:
-  # Schema version for forward compatibility - must use dict format for ModelSemVer
-  version: {major: 1, minor: 0, patch: 0}
+  # Schema version for forward compatibility (v1.1.0) - must use dict format for ModelSemVer
+  # NOTE: Per-operation configs are parsed but NOT honored in v1.1.0 (uses subcontract-level defaults).
+  # Per-operation overrides will be fully implemented in v2.0. Tracking: OMN-467
+  version: {major: 1, minor: 1, patch: 0}
 
   # Unique subcontract name (required by ModelEffectSubcontract)
   subcontract_name: "filesystem_operations_effect"
diff --git a/examples/contracts/effect/http_api_call.yaml b/examples/contracts/effect/http_api_call.yaml
index fe909b9913..e5223d70f2 100644
--- a/examples/contracts/effect/http_api_call.yaml
+++ b/examples/contracts/effect/http_api_call.yaml
@@ -64,33 +64,11 @@ contract_version:
   major: 1
   minor: 1
   patch: 0
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:601d59a4df02"
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:90a9aae3adb2"
 node_type: effect
 
-# Handler requirements for this effect contract
-handlers:
-  required:
-    - type: http
-      version: ">=1.0.0"
-  optional: []
-
-# Kafka topic subscriptions (none for this effect)
-subscriptions:
-  topics: []
-
-# Profile tags for categorization
-profile_tags:
-  - http
-  - rest-api
-  - user-management
-  - integration
-
 # ---------------------------------------------------------------------------
 # EFFECT SUBCONTRACT: Defines external I/O operations
 # ---------------------------------------------------------------------------
@@ -100,7 +78,7 @@ profile_tags:
 
 effect_operations:
   # Schema version for forward compatibility - must use dict format for ModelSemVer
-  version: {major: 1, minor: 0, patch: 0}
+  version: {major: 1, minor: 1, patch: 0}
 
   # Unique subcontract name (required by ModelEffectSubcontract)
   subcontract_name: "http_api_call_effect"
diff --git a/examples/contracts/effect/kafka_produce.yaml b/examples/contracts/effect/kafka_produce.yaml
index b7176151fc..4015a191b6 100644
--- a/examples/contracts/effect/kafka_produce.yaml
+++ b/examples/contracts/effect/kafka_produce.yaml
@@ -65,40 +65,21 @@ contract_version:
   major: 1
   minor: 1
   patch: 0
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:3d57f5429cbc"
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:2fc793ee6257"
 node_type: effect
 
-# Handler requirements for this effect contract
-handlers:
-  required:
-    - type: kafka
-      version: ">=1.0.0"
-  optional: []
-
-# Kafka topic subscriptions (this is a producer, no consumption)
-subscriptions:
-  topics: []
-
-# Profile tags for categorization
-profile_tags:
-  - kafka
-  - event-driven
-  - messaging
-  - audit
-
 # ---------------------------------------------------------------------------
 # EFFECT SUBCONTRACT: Defines Kafka message production operations
 # ---------------------------------------------------------------------------
 
 effect_operations:
-  # Schema version for forward compatibility - must use dict format for ModelSemVer
-  version: {major: 1, minor: 0, patch: 0}
+  # Subcontract schema version - must use dict format for ModelSemVer
+  # NOTE: Per-operation configs (retry_policy, circuit_breaker, response_handling) are parsed
+  # but NOT honored at the operation level in v1.x. Only subcontract-level defaults apply.
+  # Per-operation overrides will be fully implemented in v2.0. Tracking: OMN-467
+  version: {major: 1, minor: 1, patch: 0}
 
   # Unique subcontract name (required by ModelEffectSubcontract)
   subcontract_name: "kafka_produce_effect"
diff --git a/examples/contracts/effect/resilient_effect.yaml b/examples/contracts/effect/resilient_effect.yaml
index 6a8555e07b..cca6b0beb4 100644
--- a/examples/contracts/effect/resilient_effect.yaml
+++ b/examples/contracts/effect/resilient_effect.yaml
@@ -60,7 +60,7 @@
 #
 # 📚 For comprehensive security guidance, see: SECURITY.md in this directory
 #
-# v1.1.0 Contract Schema Version
+# v1.0 Contract Schema Version
 # ============================================================================
 
 # ---------------------------------------------------------------------------
@@ -71,48 +71,18 @@ contract_version:
   major: 1
   minor: 1
   patch: 0
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:bf6e50f7086f"
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:c8bf04e22bd2"
 node_type: effect
 
-# Handler requirements for this effect contract
-# Effects perform external I/O and require handlers for their operations
-handlers:
-  required:
-    # HTTP handler required for payment gateway API calls
-    - type: http
-      version: ">=1.0.0"
-  optional:
-    # Database handler optional for payment transaction persistence
-    - type: db
-      version: ">=1.0.0"
-    # Kafka handler optional for publishing payment events
-    - type: kafka
-      version: ">=1.0.0"
-
-# Kafka topic subscriptions (none for this effect)
-subscriptions:
-  topics: []
-
-# Profile tags for categorization
-profile_tags:
-  - resilience
-  - circuit-breaker
-  - payment-processing
-  - production-ready
-
 # ---------------------------------------------------------------------------
 # EFFECT SUBCONTRACT: Defines resilient external operations
 # ---------------------------------------------------------------------------
 
 effect_operations:
   # Schema version for forward compatibility - must use dict format for ModelSemVer
-  version: {major: 1, minor: 0, patch: 0}
+  version: {major: 1, minor: 1, patch: 0}
 
   # Unique subcontract name (required by ModelEffectSubcontract)
   subcontract_name: "resilient_payment_effect"
diff --git a/examples/contracts/orchestrator_data_pipeline.yaml b/examples/contracts/orchestrator_data_pipeline.yaml
index 27c6cbc0cd..dc91168fa2 100644
--- a/examples/contracts/orchestrator_data_pipeline.yaml
+++ b/examples/contracts/orchestrator_data_pipeline.yaml
@@ -20,69 +20,20 @@
 # Contract Metadata
 node_type: ORCHESTRATOR_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:0460b8943604"
-
-# Profile tags for orchestrator classification
-profile_tags:
-  - data-processing
-  - etl-pipeline
-  - parallel-execution
-  - multi-stage
-
-# Handlers configuration
-handlers:
-  required: []  # Orchestrators coordinate, may not need direct handlers
-  optional:
-    - type: local
-      version: ">=1.0.0"
-
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# See docs/architecture/CONTRACT_STABILITY_SPEC.md for normalization specification.
+fingerprint: "1.1.0:407e93f3b1d2"
 # Workflow Coordination Subcontract
 workflow_coordination:
   version: {major: 1, minor: 1, patch: 0}
   subcontract_version: {major: 1, minor: 1, patch: 0}
 
-  # Workflow Steps: Required step definitions for orchestration
-  workflow_steps:
-    - step_id: "fetch_raw_data"
-      step_name: "Fetch Raw Data"
-      step_type: "effect"
-      depends_on: []
-    - step_id: "validate_schema"
-      step_name: "Validate Schema"
-      step_type: "compute"
-      depends_on: ["fetch_raw_data"]
-    - step_id: "enrich_data"
-      step_name: "Enrich Data"
-      step_type: "compute"
-      depends_on: ["fetch_raw_data"]
-    - step_id: "aggregate_metrics"
-      step_name: "Aggregate Metrics"
-      step_type: "reducer"
-      depends_on: ["validate_schema", "enrich_data"]
-    - step_id: "quality_check"
-      step_name: "Quality Check"
-      step_type: "compute"
-      depends_on: ["aggregate_metrics"]
-    - step_id: "persist_results"
-      step_name: "Persist Results"
-      step_type: "effect"
-      depends_on: ["quality_check"]
-    - step_id: "send_notification"
-      step_name: "Send Notification"
-      step_type: "effect"
-      depends_on: ["quality_check"]
-
   # Workflow Definition: Complete workflow specification
   workflow_definition:
     # Workflow Metadata
     workflow_metadata:
       workflow_name: data_processing_pipeline
-      workflow_version: {major: 1, minor: 0, patch: 0}
+      workflow_version: {major: 1, minor: 1, patch: 0}
       description: Multi-stage data processing with validation and enrichment
       execution_mode: parallel  # Can be: sequential, parallel, batch
       author: ONEX Framework Team
diff --git a/examples/contracts/reducer_metrics_aggregator.yaml b/examples/contracts/reducer_metrics_aggregator.yaml
index 262860c6af..74993508ec 100644
--- a/examples/contracts/reducer_metrics_aggregator.yaml
+++ b/examples/contracts/reducer_metrics_aggregator.yaml
@@ -1,20 +1,10 @@
 ---
 node_type: REDUCER_GENERIC
 contract_version: {major: 1, minor: 1, patch: 0}
-
-# Contract fingerprint for drift detection (format: v{version}:{12-char-hash})
-# The 12-character hash is a truncated SHA256 of the normalized contract content
-# (excluding the fingerprint field itself to avoid circular dependency)
-# Regenerate when contract content changes using: poetry run python scripts/compute_contract_fingerprint.py
-fingerprint: "v1.1.0:1af36171af17"
-profile_tags:
-  - metrics
-  - aggregation
-  - observability
-  - time-series
-handlers:
-  required: []  # Reducers are pure state machines - no external I/O handlers
-  optional: []
+# Fingerprint: SHA-256 hash of canonical normalized contract content (excluding fingerprint field).
+# Normalization includes: sorted keys, consistent spacing, excluded fields (fingerprint, metadata).
+# Full specification: docs/architecture/CONTRACT_STABILITY_SPEC.md
+fingerprint: "1.1.0:adb6c8f6d107"
 state_transitions:
   version: {major: 1, minor: 1, patch: 0}
   state_machine_version: {major: 1, minor: 0, patch: 0}
diff --git a/scripts/README.md b/scripts/README.md
index 438b7f69e0..4a3b2b35b7 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -1,429 +1,280 @@
-# ONEX Scripts Reference
+# ONEX Scripts
 
-**Version**: 0.4.0
-**Scope**: Development scripts for contract management, validation, and code quality
+This directory contains utility scripts for ONEX development, validation, and maintenance.
 
 ---
 
 ## Table of Contents
 
-1. [Overview](#overview)
-2. [Contract Fingerprint Management](#contract-fingerprint-management)
-3. [Contract Linting](#contract-linting)
-4. [Validation Scripts](#validation-scripts)
-5. [Utility Scripts](#utility-scripts)
-6. [v1.1.0 Contract Field Reference](#v110-contract-field-reference)
-7. [Security Considerations](#security-considerations)
+1. [Contract Fingerprinting](#contract-fingerprinting)
+   - [Computing Fingerprints](#computing-fingerprints)
+   - [Regenerating Fingerprints](#regenerating-fingerprints)
+   - [Linting Contracts](#linting-contracts)
+2. [Validation Scripts](#validation-scripts)
+3. [Code Quality Scripts](#code-quality-scripts)
+4. [Quick Reference](#quick-reference)
 
 ---
 
-## Overview
+## Contract Fingerprinting
 
-This directory contains development and CI/CD scripts for the ONEX framework:
+ONEX uses deterministic SHA256 fingerprints to track contract integrity and detect drift.
 
-| Script | Purpose | Usage |
-|--------|---------|-------|
-| `compute_contract_fingerprint.py` | Compute/validate contract fingerprints | `poetry run python scripts/compute_contract_fingerprint.py <contract.yaml>` |
-| `lint_contract.py` | Lint YAML contracts for correctness | `poetry run python scripts/lint_contract.py <contract.yaml>` |
-| `cleanup.py` | Clean temporary files and caches | `poetry run python scripts/cleanup.py --tmp-only` |
-| `check_node_purity.py` | Verify node implementation purity | `poetry run python scripts/check_node_purity.py` |
-| `check_protocol_exports.py` | Validate protocol exports | `poetry run python scripts/check_protocol_exports.py` |
-| `check_transport_imports.py` | Check transport layer imports | `poetry run python scripts/check_transport_imports.py` |
-| `fix_dict_any_violations.py` | Fix dict[str, Any] anti-patterns | `poetry run python scripts/fix_dict_any_violations.py` |
+### Fingerprint Format
 
----
+```plaintext
+<semver>:<sha256-first-12-hex-chars>
+Example: 0.4.0:8fa1e2b4c9d1
+```
 
-## Contract Fingerprint Management
+**Components:**
+- **semver**: Contract's semantic version (e.g., `1.0.0`, `0.4.0`)
+- **hash**: First 12 characters of SHA256 hash of normalized contract content
 
-### Overview
+### Hash Length Justification
 
-Contract fingerprints enable drift detection between YAML contracts and their generated code.
-The fingerprint is a combination of the contract version and a truncated SHA256 hash.
+The default hash length of **12 hex characters (48 bits)** provides:
 
-**Format**: `v<semver>:<12-hex-chars>`
-**Example**: `v1.1.0:8fa1e2b4c9d1`
+- **~281 trillion possible values** (2^48)
+- **Collision probability**: With 10,000 contracts, birthday paradox gives ~0.00002% collision chance
+- **Readable fingerprints**: Short enough for human readability and copy/paste
+- **Sufficient for registry use**: Contract registries typically have hundreds to thousands of contracts
 
-### Compute a Fingerprint
+For higher security requirements, use `--hash-length 16` (64 bits) or higher.
 
-```bash
-# Compute fingerprint for a single contract
-poetry run python scripts/compute_contract_fingerprint.py contracts/runtime/runtime_orchestrator.yaml
+### Computing Fingerprints
 
-# Compute with verbose output (includes full hash)
-poetry run python scripts/compute_contract_fingerprint.py contracts/runtime/runtime_orchestrator.yaml --verbose
+**Script**: `scripts/compute_contract_fingerprint.py`
 
-# Output as JSON (for CI/CD pipelines)
-poetry run python scripts/compute_contract_fingerprint.py contracts/runtime/runtime_orchestrator.yaml --json
+Compute fingerprints without modifying files:
 
-# Process multiple contracts
-poetry run python scripts/compute_contract_fingerprint.py contracts/runtime/*.yaml
-```
+```bash
+# Compute fingerprint for a single contract
+poetry run python scripts/compute_contract_fingerprint.py contracts/my_contract.yaml
 
-### Validate Existing Fingerprints
+# Verbose output with full hash
+poetry run python scripts/compute_contract_fingerprint.py contracts/my_contract.yaml --verbose
 
-```bash
-# Validate fingerprint in contract matches computed value
-poetry run python scripts/compute_contract_fingerprint.py contracts/runtime/runtime_orchestrator.yaml --validate
+# Validate existing fingerprint matches computed
+poetry run python scripts/compute_contract_fingerprint.py contracts/my_contract.yaml --validate
 
-# Returns exit code 0 if valid, 1 if mismatch, 2 on error
+# Output as JSON for CI/CD
+poetry run python scripts/compute_contract_fingerprint.py contracts/my_contract.yaml --json
+
+# Process multiple files
+poetry run python scripts/compute_contract_fingerprint.py contracts/*.yaml
 ```
 
+**Exit Codes:**
+- `0`: Success (fingerprint computed or validation passed)
+- `1`: Validation failed (fingerprint mismatch)
+- `2`: Error (file not found, invalid format, etc.)
+
 ### Regenerating Fingerprints
 
-When you modify a contract's content, you **MUST** regenerate its fingerprint:
+**Script**: `scripts/regenerate_fingerprints.py`
 
-#### Step 1: Compute the New Fingerprint
+Update fingerprints in-place when contract content changes:
 
 ```bash
-poetry run python scripts/compute_contract_fingerprint.py path/to/your_contract.yaml
-```
+# Regenerate single contract
+poetry run python scripts/regenerate_fingerprints.py contracts/my_contract.yaml
+
+# Regenerate all contracts in directory
+poetry run python scripts/regenerate_fingerprints.py contracts/ --recursive
+
+# Dry-run: preview changes without modifying files
+poetry run python scripts/regenerate_fingerprints.py contracts/ --dry-run -v
 
-This outputs something like:
-```text
-File: path/to/your_contract.yaml
-Fingerprint: v1.1.0:a1b2c3d4e5f6
+# CI/CD: check if fingerprints are current (exits 1 if changes needed)
+poetry run python scripts/regenerate_fingerprints.py contracts/ --dry-run --json
 ```
 
-#### Step 2: Update the Contract
+**Exit Codes:**
+- `0`: All fingerprints up-to-date
+- `1`: Fingerprints were changed (drift detected)
+- `2`: Error occurred
 
-Edit the contract YAML and update the `fingerprint` field:
+**When to Regenerate:**
+- After modifying contract YAML content
+- After upgrading contract version
+- Before committing contract changes
+- In CI/CD to verify fingerprints are current
 
-```yaml
-# Before
-fingerprint: "v1.1.0:oldvalue12ab"
+### Linting Contracts
 
-# After
-fingerprint: "v1.1.0:a1b2c3d4e5f6"
-```
+**Script**: `scripts/lint_contract.py`
 
-#### Step 3: Validate the Update
+Comprehensive contract validation with fingerprint checking:
 
 ```bash
-# Confirm fingerprint is now valid
-poetry run python scripts/compute_contract_fingerprint.py path/to/your_contract.yaml --validate
-```
+# Lint single contract
+poetry run python scripts/lint_contract.py contracts/my_contract.yaml
 
-### Batch Fingerprint Regeneration
+# Lint directory recursively
+poetry run python scripts/lint_contract.py contracts/ --recursive
 
-For multiple contracts (e.g., after a major refactor):
+# Lint with baseline for drift detection
+poetry run python scripts/lint_contract.py contracts/ --baseline fingerprints.json
 
-```bash
-# Regenerate all runtime contracts
-for f in contracts/runtime/*.yaml; do
-    echo "Processing $f"
-    poetry run python scripts/compute_contract_fingerprint.py "$f"
-done
-
-# Or use --json for scripted updates
-poetry run python scripts/compute_contract_fingerprint.py contracts/runtime/*.yaml --json > fingerprints.json
-```
+# Update baseline with current fingerprints
+poetry run python scripts/lint_contract.py contracts/ --baseline fingerprints.json --update-baseline
 
-### CI/CD Integration
+# Only compute fingerprints (skip other checks)
+poetry run python scripts/lint_contract.py contracts/ --compute-fingerprint
 
-```yaml
-# Example GitHub Actions workflow step
-- name: Validate Contract Fingerprints
-  run: |
-    for contract in contracts/**/*.yaml; do
-      poetry run python scripts/compute_contract_fingerprint.py "$contract" --validate
-    done
+# Output as JSON
+poetry run python scripts/lint_contract.py contracts/ --json
 ```
 
+**Validation Checks:**
+- YAML syntax validation
+- Required field verification (`name`, `version`, `node_type`, `input_model`, `output_model`)
+- ONEX naming conventions
+- Fingerprint integrity (declared vs computed)
+- Baseline drift detection
+
+**Exit Codes:**
+- `0`: Validation passed
+- `1`: Validation failed (issues detected)
+- `2`: Script error
+
 ---
 
-## Contract Linting
+## Validation Scripts
 
-The contract linter validates YAML contracts against the ONEX schema.
+Located in `scripts/validation/`. See `scripts/validation/README.md` for details.
 
-```bash
-# Lint a single contract
-poetry run python scripts/lint_contract.py contracts/runtime/runtime_orchestrator.yaml
+### Security Validators
 
-# Lint all contracts in a directory
-poetry run python scripts/lint_contract.py contracts/
+```bash
+# Detect hardcoded secrets
+poetry run python scripts/validation/validate-secrets.py src/
 
-# Strict mode (treat warnings as errors)
-poetry run python scripts/lint_contract.py contracts/ --strict
+# Detect hardcoded environment variables
+poetry run python scripts/validation/validate-hardcoded-env-vars.py src/
 ```
 
----
+### Code Quality Validators
 
-## Validation Scripts
+```bash
+# Check for stubbed functionality
+poetry run python scripts/validation/check_stub_implementations.py
 
-Located in `scripts/validation/`, these scripts enforce ONEX conventions:
+# Validate protocol exports
+poetry run python scripts/check_protocol_exports.py
 
-| Script | Purpose |
-|--------|---------|
-| `validate-contracts.py` | Validate all contract YAML files |
-| `validate-pydantic-patterns.py` | Check Pydantic model patterns |
-| `validate-imports.py` | Verify import patterns |
-| `validate-typing-syntax.py` | Check typing syntax consistency |
-| `validate-onex-error-compliance.py` | Ensure proper error handling |
-| `validate-no-dict-methods.py` | Prevent dict method anti-patterns |
+# Check for circular imports
+poetry run python scripts/validation/test_circular_imports.py
+
+# Validate ONEX error compliance
+poetry run python scripts/validation/validate-onex-error-compliance.py src/
+```
 
-Run all validations:
+### Contract Validators
 
 ```bash
-# Individual validation
-poetry run python scripts/validation/validate-contracts.py
+# Validate contract YAML structure
+poetry run python scripts/validation/validate-contracts.py contracts/
 
-# Run all validations via pre-commit
-pre-commit run --all-files
+# Validate markdown documentation links
+poetry run python scripts/validation/validate_markdown_links.py docs/
 ```
 
 ---
 
-## Utility Scripts
+## Code Quality Scripts
 
-### cleanup.py
-
-Clean temporary files while preserving caches:
+### Cleanup
 
 ```bash
-# Clean tmp/ directory only (recommended for regular use)
+# Clean temporary files (preserves caches)
 poetry run python scripts/cleanup.py --tmp-only
 
-# Full cleanup (deletes ALL caches - slow rebuild!)
+# Full cleanup (removes ALL caches - slow rebuild!)
 poetry run python scripts/cleanup.py
 
-# Preview what would be cleaned
+# Preview cleanup actions
 poetry run python scripts/cleanup.py --dry-run
 
-# Remove tracked tmp files from git index
+# Remove tracked tmp files from git
 poetry run python scripts/cleanup.py --remove-from-git --tmp-only
 ```
 
----
-
-## v1.1.0 Contract Field Reference
-
-The v1.1.0 contract specification introduces several new fields for enhanced
-contract management and runtime behavior.
-
-### fingerprint
+### Protocol Checking
 
-**Purpose**: Drift detection between contract definition and implementation.
+```bash
+# Check protocol exports
+poetry run python scripts/check_protocol_exports.py
 
-**Format**: `"v<major>.<minor>.<patch>:<12-hex-sha256>"`
+# Check node purity (no side effects in COMPUTE nodes)
+poetry run python scripts/check_node_purity.py
 
-**Example**:
-```yaml
-fingerprint: "v1.1.0:8fa1e2b4c9d1"
+# Check transport imports
+poetry run python scripts/check_transport_imports.py
 ```
 
-**Regeneration**: Required when any contract content changes.
-See [Regenerating Fingerprints](#regenerating-fingerprints).
-
-**Security Note**: The 12-character hash prefix provides 48 bits of entropy.
-For collision probability analysis, see [Security Considerations](#security-considerations).
-
 ---
 
-### handlers
+## Quick Reference
 
-**Purpose**: Declare handler dependencies for node execution.
+### Contract Fingerprinting Workflow
 
-**Structure**:
-```yaml
-handlers:
-  required:
-    - type: <handler_type>
-      version: "<semver_constraint>"
-  optional:
-    - type: <handler_type>
-      version: "<semver_constraint>"
-```
-
-**Handler Requirements by Node Type**:
-
-| Node Type | Handler Requirements | Rationale |
-|-----------|---------------------|-----------|
-| **COMPUTE** | `required: []` (none) | Pure transformations with no external I/O. All data comes from input, all results go to output. No filesystem, database, or network access. |
-| **EFFECT** | External I/O handlers required | Handles all external interactions: filesystem, database, HTTP, message queues. Declare handlers for each I/O type used. |
-| **REDUCER** | `required: []` (FSM-driven) | State transitions driven by FSM, no direct I/O. State persistence is handled by the runtime, not the node itself. |
-| **ORCHESTRATOR** | Usually `required: []` | Coordinates other nodes via workflow definitions. May optionally use `local` handler for internal coordination, but most orchestration is declarative. |
-
-**When to Use Required vs Optional Handlers**:
+```bash
+# 1. Modify contract YAML
 
-| Handler Category | Use `required` | Use `optional` |
-|-----------------|----------------|----------------|
-| Core I/O (filesystem, database) | Yes - node cannot function | No |
-| Logging/Metrics | No | Yes - graceful degradation |
-| External APIs | Depends on criticality | Yes for optional features |
-| Caching | No | Yes - performance enhancement |
+# 2. Regenerate fingerprint
+poetry run python scripts/regenerate_fingerprints.py contracts/my_contract.yaml
 
-**Examples**:
+# 3. Verify with lint
+poetry run python scripts/lint_contract.py contracts/my_contract.yaml
 
-```yaml
-# EFFECT node with filesystem operations (required handler)
-handlers:
-  required:
-    - type: filesystem
-      version: ">=1.0.0"
-  optional: []
-
-# ORCHESTRATOR node (may not need direct handlers)
-handlers:
-  required: []  # Orchestrators coordinate, may not need direct handlers
-  optional:
-    - type: local
-      version: ">=1.0.0"
-
-# COMPUTE node with optional caching
-handlers:
-  required: []  # Pure compute, no I/O handlers needed
-  optional:
-    - type: cache
-      version: ">=1.0.0"
+# 4. Commit changes
+git add contracts/my_contract.yaml
+git commit -m "Update contract and fingerprint"
 ```
 
----
-
-### profile_tags
-
-**Purpose**: Categorization tags for contract discovery and filtering.
-
-**Structure**: List of lowercase, hyphen-separated strings.
-
-**Naming Conventions**:
-
-| Tag Category | Pattern | Examples |
-|--------------|---------|----------|
-| Node role | `<role>` | `runtime`, `kernel`, `compute` |
-| Feature area | `<feature>` | `filesystem`, `contracts`, `events` |
-| Lifecycle | `<phase>` | `loader`, `wiring`, `discovery` |
-| Capability | `<capability>` | `self-hosted`, `hot-reload` |
+### CI/CD Integration
 
-**Examples**:
-```yaml
-# Runtime orchestrator tags
-profile_tags:
-  - runtime
-  - kernel
-  - self-hosted
-  - lifecycle-management
-
-# Contract loader effect tags
-profile_tags:
-  - filesystem
-  - contracts
-  - discovery
-  - runtime
-  - loader
+```bash
+# Check fingerprints are current (fails if drift detected)
+poetry run python scripts/regenerate_fingerprints.py contracts/ -r --dry-run
+if [ $? -eq 1 ]; then
+    echo "ERROR: Fingerprints out of date. Run regenerate_fingerprints.py"
+    exit 1
+fi
 ```
 
-**Validation Rules**:
-- Tags must be non-empty strings
-- No duplicates within a contract
-- Runtime contracts MUST include `runtime` tag
-- Tags should be lowercase and hyphen-separated
-
----
-
-### subscriptions
-
-**Purpose**: Kafka topic subscriptions for event-driven contracts.
-
-**Structure**:
-```yaml
-subscriptions:
-  topics:
-    - <topic_name>
-  # OR list format for detailed subscriptions
-subscriptions:
-  - topic: <topic_name>
-    description: <description>
+```bash
+# Full contract validation
+poetry run python scripts/lint_contract.py contracts/ -r --json
 ```
 
-**Topic Naming Conventions**:
-
-All topics MUST follow the pattern: `<namespace>.<domain>.<action>`
+### Pre-commit Hook Integration
 
-| Component | Description | Examples |
-|-----------|-------------|----------|
-| Namespace | Service or module name | `runtime`, `contracts`, `nodes` |
-| Domain | Subject area | `startup`, `contracts`, `events` |
-| Action | What happened | `reload`, `ready`, `error` |
+Add to `.pre-commit-config.yaml`:
 
-**Reserved Prefixes**:
-- `runtime.*` - Runtime lifecycle events (e.g., `runtime.startup`, `runtime.shutdown`)
-- `contracts.*` - Contract-related events (e.g., `contracts.loaded`, `contracts.validated`)
-- `nodes.*` - Node lifecycle events (e.g., `nodes.registered`, `nodes.disposed`)
-
-**Examples**:
 ```yaml
-# Orchestrator subscriptions
-subscriptions:
-  - topic: runtime.startup
-    description: Trigger runtime startup sequence
-  - topic: runtime.shutdown
-    description: Trigger graceful shutdown sequence
-  - topic: runtime.contracts.reload
-    description: Trigger contract reload without full restart
-
-# Effect with no subscriptions (uses dict format)
-subscriptions:
-  topics: []
+- repo: local
+  hooks:
+    - id: regenerate-fingerprints
+      name: Regenerate Contract Fingerprints
+      entry: poetry run python scripts/regenerate_fingerprints.py
+      language: system
+      files: ^contracts/.*\.yaml$
+      pass_filenames: true
 ```
 
 ---
 
-## Security Considerations
-
-### Fingerprint Hash Truncation
-
-The fingerprint uses a **12-character (48-bit) truncated SHA256 hash**.
-
-**Collision Probability Analysis**:
-
-| Contracts | Collision Probability | Risk Level |
-|-----------|----------------------|------------|
-| 1,000 | 0.00000018% | Negligible |
-| 10,000 | 0.000018% | Negligible |
-| 100,000 | 0.0018% | Very Low |
-| 1,000,000 | 0.18% | Low |
-| 17,000,000 | 50% | Birthday paradox threshold |
-
-**Mitigation Factors**:
-1. **Version prefix**: Collisions only matter within the same semver version
-2. **Practical limits**: Most deployments have <100,000 contracts
-3. **Drift detection**: Fingerprints are for detecting unintended changes, not cryptographic security
-4. **Full hash available**: `--verbose` flag shows complete 64-character hash for verification
-
-**When Full Hash Verification is Recommended**:
-- Cross-repository contract synchronization
-- Long-term archival and auditing
-- High-security environments with strict compliance requirements
-
-**Not Recommended For**:
-- Cryptographic signatures (use proper signing instead)
-- Authentication or authorization decisions
-- Tamper-proof verification (fingerprints can be updated)
-
-### File Size Limits
-
-The fingerprint tool enforces a **10MB file size limit** to prevent DoS attacks
-from processing maliciously large files.
-
-### Path Security
-
-Contract loading enforces:
-- No path traversal (`..` sequences blocked)
-- Restricted to allowed base paths
-- Symlink escape prevention
-- Absolute path injection blocked
-
-See `io_config.security` in effect contracts for detailed configuration.
-
----
-
-## References
+## Related Documentation
 
-- [CONTRACT_STABILITY_SPEC.md](../docs/architecture/CONTRACT_STABILITY_SPEC.md) - Fingerprint specification
-- [ONEX Four-Node Architecture](../docs/architecture/ONEX_FOUR_NODE_ARCHITECTURE.md) - Node types
-- [Contract System](../docs/architecture/CONTRACT_SYSTEM.md) - Contract architecture
+- **Contract Stability Spec**: `docs/architecture/CONTRACT_STABILITY_SPEC.md`
+- **Hash Registry**: `src/omnibase_core/contracts/hash_registry.py`
+- **Security Validators**: `scripts/validation/README.md`
+- **ONEX Architecture**: `docs/architecture/ONEX_FOUR_NODE_ARCHITECTURE.md`
 
 ---
 
 **Last Updated**: 2025-12-12
-**Maintainer**: ONEX Framework Team
+**Project**: omnibase_core v0.4.0
diff --git a/scripts/regenerate_fingerprints.py b/scripts/regenerate_fingerprints.py
new file mode 100644
index 0000000000..c9346a3502
--- /dev/null
+++ b/scripts/regenerate_fingerprints.py
@@ -0,0 +1,614 @@
+#!/usr/bin/env python3
+"""
+ONEX Contract Fingerprint Regeneration Script.
+
+Regenerates fingerprints for ONEX contracts in-place by:
+1. Reading contract YAML files
+2. Computing SHA256 of canonical content (excluding fingerprint field)
+3. Updating fingerprint field with `{version}:{first-12-chars-of-hash}`
+4. Writing back YAML preserving formatting
+
+This script is essential for maintaining contract integrity after modifications.
+Run it whenever contract content changes to ensure fingerprints stay in sync.
+
+Fingerprint Format:
+    <semver>:<sha256-first-12-hex-chars>
+    Example: 0.4.0:8fa1e2b4c9d1
+
+Usage:
+    # Regenerate fingerprint for a single contract
+    poetry run python scripts/regenerate_fingerprints.py contracts/my_contract.yaml
+
+    # Regenerate fingerprints for all contracts in a directory
+    poetry run python scripts/regenerate_fingerprints.py contracts/ --recursive
+
+    # Dry-run mode (show changes without modifying files)
+    poetry run python scripts/regenerate_fingerprints.py contracts/ --dry-run
+
+    # Verbose output showing before/after fingerprints
+    poetry run python scripts/regenerate_fingerprints.py contracts/ -v
+
+    # Output results as JSON for CI/CD integration
+    poetry run python scripts/regenerate_fingerprints.py contracts/ --json
+
+Exit Codes:
+    0 - Success (fingerprints regenerated or already up-to-date)
+    1 - Some files had fingerprint changes (useful for CI to detect drift)
+    2 - Error (file not found, invalid format, etc.)
+
+When to Run:
+    - After modifying contract YAML content
+    - After upgrading contract version
+    - Before committing contract changes
+    - In CI/CD to verify fingerprints are current
+
+Related:
+    - Linear Ticket: OMN-263
+    - Architecture: docs/architecture/CONTRACT_STABILITY_SPEC.md
+    - Hash Registry: src/omnibase_core/contracts/hash_registry.py
+    - Fingerprint CLI: scripts/compute_contract_fingerprint.py
+    - Contract Linter: scripts/lint_contract.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import yaml
+from pydantic import BaseModel  # noqa: TC002 - Used at runtime in type dict
+
+from omnibase_core.contracts.hash_registry import compute_contract_fingerprint
+from omnibase_core.enums.enum_core_error_code import EnumCoreErrorCode
+from omnibase_core.models.contracts.model_contract_compute import ModelContractCompute
+from omnibase_core.models.contracts.model_contract_effect import ModelContractEffect
+from omnibase_core.models.contracts.model_contract_orchestrator import (
+    ModelContractOrchestrator,
+)
+from omnibase_core.models.contracts.model_contract_reducer import ModelContractReducer
+from omnibase_core.models.contracts.model_yaml_contract import ModelYamlContract
+from omnibase_core.models.errors.model_onex_error import ModelOnexError
+
+if TYPE_CHECKING:
+    from omnibase_core.models.contracts.model_contract_fingerprint import (
+        ModelContractFingerprint,
+    )
+
+
+# ==============================================================================
+# CONSTANTS
+# ==============================================================================
+
+MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024  # 10MB - DoS prevention
+
+# Node type to model class mapping (from compute_contract_fingerprint.py)
+NODE_TYPE_TO_MODEL: dict[str, type[BaseModel]] = {
+    # COMPUTE types
+    "COMPUTE_GENERIC": ModelContractCompute,
+    "TRANSFORMER": ModelContractCompute,
+    "AGGREGATOR": ModelContractCompute,
+    "FUNCTION": ModelContractCompute,
+    "MODEL": ModelContractCompute,
+    "PLUGIN": ModelContractCompute,
+    "SCHEMA": ModelContractCompute,
+    "NODE": ModelContractCompute,
+    "SERVICE": ModelContractCompute,
+    # EFFECT types
+    "EFFECT_GENERIC": ModelContractEffect,
+    "GATEWAY": ModelContractEffect,
+    "VALIDATOR": ModelContractEffect,
+    "TOOL": ModelContractEffect,
+    "AGENT": ModelContractEffect,
+    # REDUCER types
+    "REDUCER_GENERIC": ModelContractReducer,
+    # ORCHESTRATOR types
+    "ORCHESTRATOR_GENERIC": ModelContractOrchestrator,
+    "WORKFLOW": ModelContractOrchestrator,
+}
+
+
+# ==============================================================================
+# DATA CLASSES
+# ==============================================================================
+
+
+@dataclass
+class RegenerateResult:
+    """Result of regenerating a single contract file's fingerprint."""
+
+    file_path: Path
+    old_fingerprint: str | None
+    new_fingerprint: str | None
+    changed: bool
+    error: str | None = None
+    skipped: bool = False
+    skip_reason: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        """Convert to dictionary for JSON output."""
+        return {
+            "file": str(self.file_path),
+            "old_fingerprint": self.old_fingerprint,
+            "new_fingerprint": self.new_fingerprint,
+            "changed": self.changed,
+            "error": self.error,
+            "skipped": self.skipped,
+            "skip_reason": self.skip_reason,
+        }
+
+
+# ==============================================================================
+# CONTRACT MODEL DETECTION
+# ==============================================================================
+
+
+def detect_contract_model(contract_data: dict[str, object]) -> type[BaseModel] | None:
+    """Detect the appropriate contract model class from YAML data.
+
+    Args:
+        contract_data: Parsed YAML contract data as a dictionary.
+
+    Returns:
+        Pydantic model class for the contract type, or None if not determinable.
+    """
+    node_type = contract_data.get("node_type")
+
+    if node_type is None or not isinstance(node_type, str):
+        return None
+
+    # Check for strict contract (has version and required fields)
+    has_strict_fields = all(
+        field in contract_data
+        for field in ("name", "input_model", "output_model", "description")
+    )
+    has_version = "version" in contract_data
+    has_contract_version = "contract_version" in contract_data
+
+    if has_version and not has_contract_version and has_strict_fields:
+        model_class = NODE_TYPE_TO_MODEL.get(node_type.upper())
+        if model_class is not None:
+            return model_class
+
+    # Fall back to flexible ModelYamlContract
+    return ModelYamlContract
+
+
+# ==============================================================================
+# FINGERPRINT REGENERATION
+# ==============================================================================
+
+
+@dataclass
+class FingerprintResult:
+    """Result of fingerprint computation attempt."""
+
+    fingerprint: ModelContractFingerprint | None
+    error: str | None = None
+
+
+def compute_fingerprint_for_contract(
+    contract_data: dict[str, object],
+) -> FingerprintResult:
+    """Compute fingerprint for parsed contract data.
+
+    Args:
+        contract_data: Parsed YAML contract data.
+
+    Returns:
+        FingerprintResult with computed fingerprint or error message.
+    """
+    model_class = detect_contract_model(contract_data)
+    if model_class is None:
+        return FingerprintResult(
+            fingerprint=None,
+            error="Could not detect contract model type",
+        )
+
+    try:
+        # Remove existing fingerprint to avoid circular dependency
+        data_for_fingerprint = {
+            k: v for k, v in contract_data.items() if k != "fingerprint"
+        }
+        contract = model_class.model_validate(data_for_fingerprint)
+        fingerprint = compute_contract_fingerprint(contract)
+        return FingerprintResult(fingerprint=fingerprint)
+    except ModelOnexError as e:
+        return FingerprintResult(
+            fingerprint=None,
+            error=f"ONEX error: {e.message}",
+        )
+    except ValueError as e:
+        # Pydantic ValidationError inherits from ValueError
+        return FingerprintResult(
+            fingerprint=None,
+            error=f"Validation error: {e}",
+        )
+    except TypeError as e:
+        return FingerprintResult(
+            fingerprint=None,
+            error=f"Type error: {e}",
+        )
+
+
+def update_fingerprint_in_yaml(
+    content: str,
+    new_fingerprint: str,
+) -> str:
+    """Update fingerprint field in YAML content while preserving formatting.
+
+    Args:
+        content: Original YAML file content.
+        new_fingerprint: New fingerprint value to set.
+
+    Returns:
+        Updated YAML content with new fingerprint.
+    """
+    # Pattern to match existing fingerprint field
+    fingerprint_pattern = re.compile(
+        r'^(\s*)fingerprint:\s*["\']?[\w.:/-]+["\']?\s*$',
+        re.MULTILINE,
+    )
+
+    match = fingerprint_pattern.search(content)
+    if match:
+        # Replace existing fingerprint
+        indent = match.group(1)
+        return fingerprint_pattern.sub(
+            f'{indent}fingerprint: "{new_fingerprint}"',
+            content,
+        )
+
+    # No existing fingerprint - add after version field
+    version_pattern = re.compile(
+        r'^(\s*)(version:\s*["\']?[\w./-]+["\']?\s*)$',
+        re.MULTILINE,
+    )
+    version_match = version_pattern.search(content)
+    if version_match:
+        indent = version_match.group(1)
+        version_line = version_match.group(0)
+        return content.replace(
+            version_line,
+            f'{version_line}\n{indent}fingerprint: "{new_fingerprint}"',
+        )
+
+    # Fallback: add at end of file
+    return content.rstrip() + f'\nfingerprint: "{new_fingerprint}"\n'
+
+
+def regenerate_fingerprint(
+    file_path: Path,
+    dry_run: bool = False,
+) -> RegenerateResult:
+    """Regenerate fingerprint for a single contract file.
+
+    Args:
+        file_path: Path to the contract YAML file.
+        dry_run: If True, don't modify the file.
+
+    Returns:
+        RegenerateResult with details of the operation.
+    """
+    # Validate file exists
+    if not file_path.exists():
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            error=f"File not found: {file_path}",
+        )
+
+    if not file_path.is_file():
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            error=f"Not a file: {file_path}",
+        )
+
+    # Check file size
+    try:
+        file_size = file_path.stat().st_size
+        if file_size > MAX_FILE_SIZE_BYTES:
+            return RegenerateResult(
+                file_path=file_path,
+                old_fingerprint=None,
+                new_fingerprint=None,
+                changed=False,
+                error=f"File too large: {file_size} bytes",
+            )
+    except OSError as e:
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            error=f"Cannot read file: {e}",
+        )
+
+    # Read file
+    try:
+        content = file_path.read_text(encoding="utf-8")
+    except UnicodeDecodeError as e:
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            error=f"Encoding error: {e}",
+        )
+
+    # Parse YAML first, then validate with Pydantic model
+    # Note: yaml.safe_load is required here as the first step before Pydantic validation
+    # because we need to detect the contract type from node_type before selecting the model
+    try:
+        contract_data = yaml.safe_load(content)  # noqa: ONEX-YAML
+    except yaml.YAMLError as e:
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            error=f"YAML parse error: {e}",
+        )
+
+    if not isinstance(contract_data, dict):
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            skipped=True,
+            skip_reason="Not a YAML mapping (might not be a contract)",
+        )
+
+    # Check for required contract fields
+    if "node_type" not in contract_data:
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            skipped=True,
+            skip_reason="Missing node_type field (not an ONEX contract)",
+        )
+
+    # Get existing fingerprint
+    old_fingerprint = contract_data.get("fingerprint")
+    if old_fingerprint and not isinstance(old_fingerprint, str):
+        old_fingerprint = str(old_fingerprint)
+
+    # Compute new fingerprint
+    fingerprint_result = compute_fingerprint_for_contract(contract_data)
+    if fingerprint_result.fingerprint is None:
+        return RegenerateResult(
+            file_path=file_path,
+            old_fingerprint=old_fingerprint,
+            new_fingerprint=None,
+            changed=False,
+            error=fingerprint_result.error or "Failed to compute fingerprint",
+        )
+
+    new_fingerprint = str(fingerprint_result.fingerprint)
+
+    # Check if changed
+    changed = old_fingerprint != new_fingerprint
+
+    # Write back if not dry run and changed
+    if changed and not dry_run:
+        try:
+            updated_content = update_fingerprint_in_yaml(content, new_fingerprint)
+            file_path.write_text(updated_content, encoding="utf-8")
+        except OSError as e:
+            return RegenerateResult(
+                file_path=file_path,
+                old_fingerprint=old_fingerprint,
+                new_fingerprint=new_fingerprint,
+                changed=changed,
+                error=f"Failed to write file: {e}",
+            )
+
+    return RegenerateResult(
+        file_path=file_path,
+        old_fingerprint=old_fingerprint,
+        new_fingerprint=new_fingerprint,
+        changed=changed,
+    )
+
+
+# ==============================================================================
+# FILE DISCOVERY
+# ==============================================================================
+
+
+def find_contract_files(
+    directory: Path,
+    recursive: bool = False,
+) -> list[Path]:
+    """Find contract YAML files in a directory.
+
+    Args:
+        directory: Directory to search.
+        recursive: Search recursively.
+
+    Returns:
+        List of contract file paths.
+    """
+    patterns = ["*.yaml", "*.yml"]
+    files: list[Path] = []
+
+    for pattern in patterns:
+        if recursive:
+            files.extend(directory.rglob(pattern))
+        else:
+            files.extend(directory.glob(pattern))
+
+    # Filter out non-contract directories
+    excluded_dirs = {
+        "__pycache__",
+        ".git",
+        "node_modules",
+        ".venv",
+        "archived",
+        "archive",
+    }
+    contract_files = [
+        f for f in files if not any(part in excluded_dirs for part in f.parts)
+    ]
+
+    return sorted(contract_files)
+
+
+# ==============================================================================
+# MAIN ENTRY POINT
+# ==============================================================================
+
+
+def main() -> int:
+    """Main entry point for fingerprint regeneration CLI.
+
+    Returns:
+        Exit code:
+        - 0: Success (all fingerprints up-to-date or regenerated)
+        - 1: Fingerprints were changed (useful for CI drift detection)
+        - 2: Error occurred
+    """
+    parser = argparse.ArgumentParser(
+        description="Regenerate fingerprints for ONEX contracts",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Regenerate single contract
+    poetry run python scripts/regenerate_fingerprints.py contracts/my_contract.yaml
+
+    # Regenerate all contracts in directory
+    poetry run python scripts/regenerate_fingerprints.py contracts/ --recursive
+
+    # Dry-run (preview changes)
+    poetry run python scripts/regenerate_fingerprints.py contracts/ --dry-run -v
+
+    # CI/CD: check if fingerprints are current
+    poetry run python scripts/regenerate_fingerprints.py contracts/ --dry-run --json
+""",
+    )
+    parser.add_argument(
+        "paths",
+        type=Path,
+        nargs="+",
+        help="Contract file(s) or directory(ies) to process",
+    )
+    parser.add_argument(
+        "--recursive",
+        "-r",
+        action="store_true",
+        help="Recursively search directories",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview changes without modifying files",
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed output for each file",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results as JSON",
+    )
+
+    args = parser.parse_args()
+
+    # Collect files to process
+    files_to_process: list[Path] = []
+    for path in args.paths:
+        if path.is_file():
+            files_to_process.append(path)
+        elif path.is_dir():
+            files_to_process.extend(find_contract_files(path, args.recursive))
+        else:
+            if args.json:
+                print(json.dumps({"error": f"Path not found: {path}"}))
+            else:
+                print(f"Error: Path not found: {path}", file=sys.stderr)
+            return 2
+
+    if not files_to_process:
+        if args.json:
+            print(json.dumps({"error": "No contract files found"}))
+        else:
+            print("No contract files found", file=sys.stderr)
+        return 2
+
+    # Process files
+    results: list[RegenerateResult] = []
+    for file_path in files_to_process:
+        result = regenerate_fingerprint(file_path, dry_run=args.dry_run)
+        results.append(result)
+
+    # Calculate summary
+    total_files = len(results)
+    changed_count = sum(1 for r in results if r.changed)
+    error_count = sum(1 for r in results if r.error)
+    skipped_count = sum(1 for r in results if r.skipped)
+
+    # Output results
+    if args.json:
+        output = {
+            "summary": {
+                "total_files": total_files,
+                "changed": changed_count,
+                "errors": error_count,
+                "skipped": skipped_count,
+                "dry_run": args.dry_run,
+            },
+            "results": [r.to_dict() for r in results],
+        }
+        print(json.dumps(output, indent=2))
+    else:
+        if args.verbose or args.dry_run:
+            for result in results:
+                if result.error:
+                    print(f"ERROR: {result.file_path}: {result.error}")
+                elif result.skipped:
+                    print(f"SKIP: {result.file_path}: {result.skip_reason}")
+                elif result.changed:
+                    action = "WOULD UPDATE" if args.dry_run else "UPDATED"
+                    print(f"{action}: {result.file_path}")
+                    print(f"  Old: {result.old_fingerprint or '(none)'}")
+                    print(f"  New: {result.new_fingerprint}")
+                elif args.verbose:
+                    print(f"OK: {result.file_path}: {result.new_fingerprint}")
+
+        # Summary
+        print()
+        print("=" * 60)
+        print("Fingerprint Regeneration Summary")
+        print("=" * 60)
+        print(f"  Total files: {total_files}")
+        print(f"  Changed: {changed_count}")
+        print(f"  Errors: {error_count}")
+        print(f"  Skipped: {skipped_count}")
+        if args.dry_run:
+            print("  Mode: DRY RUN (no files modified)")
+
+    # Return exit code
+    if error_count > 0:
+        return 2
+    if changed_count > 0:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/omnibase_core/models/common/model_config_schema_property.py b/src/omnibase_core/models/common/model_config_schema_property.py
new file mode 100644
index 0000000000..6deedd0734
--- /dev/null
+++ b/src/omnibase_core/models/common/model_config_schema_property.py
@@ -0,0 +1,106 @@
+"""
+Typed schema property model for mixin configuration.
+
+This module provides strongly-typed schema properties for configuration patterns.
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+# Valid JSON Schema types
+JsonSchemaType = Literal[
+    "string", "integer", "boolean", "number", "array", "object", "null"
+]
+
+# Valid enum value types (matches JSON Schema primitive types)
+EnumValue = str | int | float | bool | None
+
+
+class ModelConfigSchemaProperty(BaseModel):
+    """
+    Typed schema property for mixin configuration.
+
+    Replaces nested dict[str, Any] in config_schema field
+    with explicit typed fields for JSON Schema properties.
+    """
+
+    model_config = ConfigDict(
+        frozen=True,
+        strict=True,
+        extra="forbid",
+    )
+
+    type: JsonSchemaType = Field(
+        default="string",
+        description="Property type (string, integer, boolean, number, array, object, null)",
+    )
+    description: str | None = Field(
+        default=None,
+        description="Property description",
+    )
+    default: str | int | float | bool | None = Field(
+        default=None,
+        description="Default value (type should match the 'type' field)",
+    )
+    enum: list[EnumValue] | None = Field(
+        default=None,
+        description="Allowed enum values (supports strings, numbers, booleans, and null)",
+    )
+    required: bool = Field(
+        default=False,
+        description="Whether this property is required",
+    )
+    min_value: float | None = Field(
+        default=None,
+        description="Minimum value for numeric types",
+    )
+    max_value: float | None = Field(
+        default=None,
+        description="Maximum value for numeric types",
+    )
+
+    @model_validator(mode="after")
+    def _validate_default_type_matches(self) -> "ModelConfigSchemaProperty":
+        """Validate that the default value type matches the declared type field."""
+        if self.default is None:
+            return self
+
+        # Map JSON Schema types to Python types for validation
+        type_to_python: dict[str, type | tuple[type, ...]] = {
+            "string": str,
+            "integer": int,
+            "number": (int, float),
+            "boolean": bool,
+            "array": list,
+            "object": dict,
+            # Note: "null" type with non-None default is already handled above
+        }
+
+        expected_types = type_to_python.get(self.type)
+        if expected_types is None:
+            # For "null" type, default should be None (already checked above)
+            if self.type == "null":
+                raise ValueError(
+                    f"Default value {self.default!r} is not valid for type 'null'. "
+                    "Null type can only have None as default."
+                )
+            return self
+
+        # Special handling: integer type should not accept float (unless it's a whole number)
+        if self.type == "integer" and isinstance(self.default, float):
+            if not self.default.is_integer():
+                raise ValueError(
+                    f"Default value {self.default!r} is a float but type is 'integer'. "
+                    "Use an integer value instead."
+                )
+        elif not isinstance(self.default, expected_types):
+            raise ValueError(
+                f"Default value {self.default!r} (type: {type(self.default).__name__}) "
+                f"does not match declared type '{self.type}'"
+            )
+
+        return self
+
+
+__all__ = ["ModelConfigSchemaProperty", "EnumValue", "JsonSchemaType"]
diff --git a/src/omnibase_core/models/common/model_custom_health_metrics.py b/src/omnibase_core/models/common/model_custom_health_metrics.py
new file mode 100644
index 0000000000..e9968ce2ad
--- /dev/null
+++ b/src/omnibase_core/models/common/model_custom_health_metrics.py
@@ -0,0 +1,64 @@
+"""
+Typed custom metrics model for health monitoring.
+
+This module provides strongly-typed metrics for health monitoring patterns.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class ModelCustomHealthMetrics(BaseModel):
+    """
+    Typed custom metrics for health monitoring.
+
+    Replaces dict[str, Any] custom_metrics field in ModelHealthMetrics
+    with explicit typed fields for custom health metrics.
+    """
+
+    status: str | None = Field(
+        default=None,
+        description="Health status (healthy, warning, critical, error)",
+    )
+    status_code: float | None = Field(
+        default=None,
+        description="Numeric status code (1.0=healthy, 0.5=warning, 0.0=critical)",
+    )
+    queue_depth: int | None = Field(
+        default=None,
+        description="Current queue depth",
+        ge=0,
+    )
+    cache_hit_rate: float | None = Field(
+        default=None,
+        description="Cache hit rate (0.0 to 1.0)",
+        ge=0.0,
+        le=1.0,
+    )
+    thread_count: int | None = Field(
+        default=None,
+        description="Current thread count",
+        ge=0,
+    )
+    open_connections: int | None = Field(
+        default=None,
+        description="Number of open connections",
+        ge=0,
+    )
+    disk_usage_percent: float | None = Field(
+        default=None,
+        description="Disk usage percentage",
+        ge=0.0,
+        le=100.0,
+    )
+    network_io_bytes: int | None = Field(
+        default=None,
+        description="Network I/O in bytes",
+        ge=0,
+    )
+    custom_values: dict[str, float] = Field(
+        default_factory=dict,
+        description="Additional custom numeric metrics",
+    )
+
+
+__all__ = ["ModelCustomHealthMetrics"]
diff --git a/src/omnibase_core/models/common/model_effect_metadata.py b/src/omnibase_core/models/common/model_effect_metadata.py
new file mode 100644
index 0000000000..6d6b132915
--- /dev/null
+++ b/src/omnibase_core/models/common/model_effect_metadata.py
@@ -0,0 +1,61 @@
+"""
+Typed metadata model for effect input/output.
+
+This module provides strongly-typed metadata for effect patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from omnibase_core.protocols.base import LiteralEventPriority
+
+
+class ModelEffectMetadata(BaseModel):
+    """
+    Typed metadata for effect input/output.
+
+    Replaces dict[str, Any] metadata field in ModelEffectInput/Output
+    with explicit typed fields for effect metadata.
+
+    Note: All fields are optional as metadata may be partially populated
+    depending on the source and context. This is intentional for metadata
+    models that aggregate information from multiple sources.
+    """
+
+    model_config = ConfigDict(extra="forbid", from_attributes=True)
+
+    source: str | None = Field(
+        default=None,
+        description="Source identifier",
+    )
+    trace_id: str | None = Field(
+        default=None,
+        description="Distributed tracing identifier",
+    )
+    span_id: str | None = Field(
+        default=None,
+        description="Span identifier for tracing",
+    )
+    correlation_id: str | None = Field(
+        default=None,
+        description="Correlation ID for request tracking",
+    )
+    environment: str | None = Field(
+        default=None,
+        description="Deployment environment",
+    )
+    tags: list[str] = Field(
+        default_factory=list,
+        description="Tags for categorization",
+    )
+    priority: LiteralEventPriority | None = Field(
+        default=None,
+        description="Operation priority (low, normal, high, critical)",
+    )
+    retry_count: int | None = Field(
+        default=None,
+        description="Number of retry attempts",
+        ge=0,
+    )
+
+
+__all__ = ["ModelEffectMetadata"]
diff --git a/src/omnibase_core/models/common/model_event_subscription_config.py b/src/omnibase_core/models/common/model_event_subscription_config.py
new file mode 100644
index 0000000000..dda9e7f7ca
--- /dev/null
+++ b/src/omnibase_core/models/common/model_event_subscription_config.py
@@ -0,0 +1,50 @@
+"""
+Typed event subscription configuration model.
+
+This module provides strongly-typed configuration for event subscription patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelEventSubscriptionConfig(BaseModel):
+    """
+    Typed event subscription configuration.
+
+    Replaces list[dict[str, Any]] event_subscriptions field in ModelYamlContract
+    with explicit typed fields for event subscriptions.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    event_type: str = Field(
+        ...,
+        description="Event type pattern to subscribe to",
+    )
+    filter_expression: str | None = Field(
+        default=None,
+        description="Filter expression for event matching",
+    )
+    handler: str | None = Field(
+        default=None,
+        description="Handler method or function name",
+    )
+    priority: int = Field(
+        default=0,
+        description="Subscription priority (0-100, higher = more urgent)",
+        ge=0,
+        le=100,
+    )
+    batch_size: int | None = Field(
+        default=None,
+        description="Batch size for batched processing",
+        ge=1,
+    )
+    timeout_ms: int | None = Field(
+        default=None,
+        description="Processing timeout in milliseconds",
+        ge=0,
+    )
+
+
+__all__ = ["ModelEventSubscriptionConfig"]
diff --git a/src/omnibase_core/models/common/model_graph_node_data.py b/src/omnibase_core/models/common/model_graph_node_data.py
new file mode 100644
index 0000000000..5a241fa96c
--- /dev/null
+++ b/src/omnibase_core/models/common/model_graph_node_data.py
@@ -0,0 +1,57 @@
+"""
+Typed data model for graph nodes.
+
+This module provides strongly-typed data for graph node patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelGraphNodeData(BaseModel):
+    """
+    Typed data for graph nodes.
+
+    Replaces dict[str, Any] data field in ModelGraphNode
+    with explicit typed fields for graph node data.
+    """
+
+    state: str | None = Field(
+        default=None,
+        description="Current node state",
+    )
+    priority: int | None = Field(
+        default=None,
+        description="Node execution priority (0-100, higher = more urgent)",
+        ge=0,
+        le=100,
+    )
+    timeout_ms: int | None = Field(
+        default=None,
+        description="Node execution timeout in milliseconds",
+        ge=0,
+    )
+    retry_count: int | None = Field(
+        default=None,
+        description="Maximum retry count",
+        ge=0,
+    )
+    condition: str | None = Field(
+        default=None,
+        description="Condition expression for decision nodes",
+    )
+    output_mapping: dict[str, str] = Field(
+        default_factory=dict,
+        description="Output variable mappings",
+    )
+    error_handler: str | None = Field(
+        default=None,
+        description="Error handler node ID",
+    )
+
+    model_config = ConfigDict(
+        extra="forbid",  # Prevent silent field drops during migration
+        validate_assignment=True,
+    )
+
+
+__all__ = ["ModelGraphNodeData"]
diff --git a/src/omnibase_core/models/common/model_graph_node_inputs.py b/src/omnibase_core/models/common/model_graph_node_inputs.py
new file mode 100644
index 0000000000..5b1ab6ad8a
--- /dev/null
+++ b/src/omnibase_core/models/common/model_graph_node_inputs.py
@@ -0,0 +1,41 @@
+"""
+Typed inputs model for graph nodes.
+
+This module provides strongly-typed inputs for graph node patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelGraphNodeInputs(BaseModel):
+    """
+    Typed inputs for graph nodes.
+
+    Replaces dict[str, Any] inputs field in ModelGraphNode
+    with explicit typed fields for graph node inputs.
+
+    Note: Fields use dict[str, str] per ONEX strict typing standards.
+    For complex values, serialize to JSON strings.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    parameters: dict[str, str] = Field(
+        default_factory=dict,
+        description="Input parameters as key-value string pairs",
+    )
+    from_outputs: dict[str, str] = Field(
+        default_factory=dict,
+        description="Mappings from other node outputs (node_id.output_name -> local_name)",
+    )
+    constants: dict[str, str] = Field(
+        default_factory=dict,
+        description="Constant input values as strings",
+    )
+    environment_vars: list[str] = Field(
+        default_factory=list,
+        description="Environment variables to inject",
+    )
+
+
+__all__ = ["ModelGraphNodeInputs"]
diff --git a/src/omnibase_core/models/common/model_intent_payload.py b/src/omnibase_core/models/common/model_intent_payload.py
new file mode 100644
index 0000000000..0d42cb41d9
--- /dev/null
+++ b/src/omnibase_core/models/common/model_intent_payload.py
@@ -0,0 +1,85 @@
+"""
+Typed payload model for intent declarations.
+
+This module provides strongly-typed payloads for intent patterns.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class ModelIntentPayload(BaseModel):
+    """
+    Typed payload for intent declarations.
+
+    Replaces dict[str, Any] payload field in ModelIntent
+    with explicit typed fields for intent payloads.
+    """
+
+    # Event emission fields
+    event_type: str | None = Field(
+        default=None,
+        description="Event type to emit",
+    )
+    event_data: dict[str, str] = Field(
+        default_factory=dict,
+        description="Event data as key-value pairs",
+    )
+
+    # Logging fields
+    log_level: str | None = Field(
+        default=None,
+        description="Log level (debug, info, warn, error)",
+    )
+    log_message: str | None = Field(
+        default=None,
+        description="Log message content",
+    )
+
+    # Storage fields
+    storage_key: str | None = Field(
+        default=None,
+        description="Storage key for write operations",
+    )
+    storage_value: str | None = Field(
+        default=None,
+        description="Value to store",
+    )
+
+    # Notification fields
+    notification_type: str | None = Field(
+        default=None,
+        description="Type of notification",
+    )
+    recipients: list[str] = Field(
+        default_factory=list,
+        description="Notification recipients",
+    )
+    subject: str | None = Field(
+        default=None,
+        description="Notification subject",
+    )
+    body: str | None = Field(
+        default=None,
+        description="Notification body",
+    )
+
+    # HTTP request fields
+    url: str | None = Field(
+        default=None,
+        description="HTTP request URL",
+    )
+    method: str | None = Field(
+        default=None,
+        description="HTTP method",
+    )
+    headers: dict[str, str] = Field(
+        default_factory=dict,
+        description="HTTP headers",
+    )
+    request_body: str | None = Field(
+        default=None,
+        description="HTTP request body",
+    )
+
+
+__all__ = ["ModelIntentPayload"]
diff --git a/src/omnibase_core/models/common/model_introspection_custom_metrics.py b/src/omnibase_core/models/common/model_introspection_custom_metrics.py
new file mode 100644
index 0000000000..af3bd9dccb
--- /dev/null
+++ b/src/omnibase_core/models/common/model_introspection_custom_metrics.py
@@ -0,0 +1,54 @@
+"""
+Typed custom metrics model for introspection additional info.
+
+This module provides strongly-typed metrics for introspection patterns.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class ModelIntrospectionCustomMetrics(BaseModel):
+    """
+    Typed custom metrics for introspection additional info.
+
+    Replaces dict[str, Any] custom_metrics field in ModelIntrospectionAdditionalInfo
+    with explicit typed fields for introspection metrics.
+    """
+
+    request_count: int | None = Field(
+        default=None,
+        description="Total request count",
+        ge=0,
+    )
+    error_count: int | None = Field(
+        default=None,
+        description="Total error count",
+        ge=0,
+    )
+    average_latency_ms: float | None = Field(
+        default=None,
+        description="Average latency in milliseconds",
+        ge=0.0,
+    )
+    p99_latency_ms: float | None = Field(
+        default=None,
+        description="99th percentile latency in milliseconds",
+        ge=0.0,
+    )
+    throughput_per_second: float | None = Field(
+        default=None,
+        description="Throughput in requests per second",
+        ge=0.0,
+    )
+    cache_size: int | None = Field(
+        default=None,
+        description="Current cache size",
+        ge=0,
+    )
+    custom_values: dict[str, float] = Field(
+        default_factory=dict,
+        description="Additional custom numeric metrics",
+    )
+
+
+__all__ = ["ModelIntrospectionCustomMetrics"]
diff --git a/src/omnibase_core/models/common/model_mixin_config_schema.py b/src/omnibase_core/models/common/model_mixin_config_schema.py
new file mode 100644
index 0000000000..5fe5b0baac
--- /dev/null
+++ b/src/omnibase_core/models/common/model_mixin_config_schema.py
@@ -0,0 +1,55 @@
+"""
+Typed configuration schema model for mixins.
+
+This module provides strongly-typed configuration schemas for mixin patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from .model_config_schema_property import ModelConfigSchemaProperty
+
+
+class ModelMixinConfigSchema(BaseModel):
+    """
+    Typed configuration schema for mixins.
+
+    Replaces dict[str, Any] config_schema field in ModelMixinInfo
+    with explicit typed fields for mixin configuration.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    properties: dict[str, ModelConfigSchemaProperty] = Field(
+        default_factory=dict,
+        description="Schema properties mapped by name",
+    )
+    required_properties: list[str] = Field(
+        default_factory=list,
+        description="List of required property names",
+    )
+    additional_properties_allowed: bool = Field(
+        default=True,
+        description="Whether additional properties are allowed",
+    )
+
+    @model_validator(mode="after")
+    def _validate_required_properties_subset(self) -> "ModelMixinConfigSchema":
+        """Validate that required_properties is a subset of properties keys."""
+        if not self.required_properties:
+            return self
+
+        property_names = set(self.properties.keys())
+        required_set = set(self.required_properties)
+        undefined_required = required_set - property_names
+
+        if undefined_required:
+            raise ValueError(
+                f"required_properties contains undefined properties: "
+                f"{sorted(undefined_required)}. "
+                f"Valid properties are: {sorted(property_names)}"
+            )
+
+        return self
+
+
+__all__ = ["ModelMixinConfigSchema"]
diff --git a/src/omnibase_core/models/common/model_node_capabilities_metadata.py b/src/omnibase_core/models/common/model_node_capabilities_metadata.py
new file mode 100644
index 0000000000..b3f7cab068
--- /dev/null
+++ b/src/omnibase_core/models/common/model_node_capabilities_metadata.py
@@ -0,0 +1,60 @@
+"""
+Typed metadata model for node capabilities.
+
+This module provides strongly-typed metadata for node capability patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelNodeCapabilitiesMetadata(BaseModel):
+    """
+    Typed metadata for node capabilities.
+
+    Replaces dict[str, Any] metadata field in ModelNodeCapabilities
+    with explicit typed fields for common node metadata.
+
+    Note: All fields are optional as metadata may be partially populated
+    depending on the source and context. This is intentional for metadata
+    models that aggregate information from multiple sources.
+    """
+
+    model_config = ConfigDict(extra="forbid", from_attributes=True)
+
+    description: str | None = Field(
+        default=None,
+        description="Human-readable description of the node",
+    )
+    author: str | None = Field(
+        default=None,
+        description="Author or maintainer of the node",
+    )
+    copyright: str | None = Field(
+        default=None,
+        description="Copyright information for the node",
+    )
+    trust_score: float | None = Field(
+        default=None,
+        description="Trust score for the node (0.0 to 1.0)",
+        ge=0.0,
+        le=1.0,
+    )
+    documentation_url: str | None = Field(
+        default=None,
+        description="URL to node documentation",
+    )
+    source_repository: str | None = Field(
+        default=None,
+        description="Source code repository URL",
+    )
+    license: str | None = Field(
+        default=None,
+        description="Software license identifier",
+    )
+    maintainers: list[str] = Field(
+        default_factory=list,
+        description="List of node maintainers",
+    )
+
+
+__all__ = ["ModelNodeCapabilitiesMetadata"]
diff --git a/src/omnibase_core/models/common/model_operation_data.py b/src/omnibase_core/models/common/model_operation_data.py
new file mode 100644
index 0000000000..111313c388
--- /dev/null
+++ b/src/omnibase_core/models/common/model_operation_data.py
@@ -0,0 +1,92 @@
+"""
+Typed operation data model for effect input.
+
+This module provides strongly-typed operation data for effect patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelOperationData(BaseModel):
+    """
+    Typed operation data for effect input.
+
+    Replaces dict[str, Any] operation_data field in ModelEffectInput
+    with explicit typed fields for effect operations.
+
+    Note: Dict fields use dict[str, str] per ONEX strict typing standards.
+    For complex values, serialize to JSON strings.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    # Common fields across all effect types
+    action: str | None = Field(
+        default=None,
+        description="Action to perform",
+    )
+    target: str | None = Field(
+        default=None,
+        description="Target resource for the operation",
+    )
+
+    # Database operation fields
+    table: str | None = Field(
+        default=None,
+        description="Database table name",
+    )
+    query: str | None = Field(
+        default=None,
+        description="Database query string",
+    )
+    parameters: dict[str, str] = Field(
+        default_factory=dict,
+        description="Query parameters as string key-value pairs",
+    )
+
+    # API call fields
+    url: str | None = Field(
+        default=None,
+        description="API endpoint URL",
+    )
+    method: str | None = Field(
+        default=None,
+        description="HTTP method (GET, POST, PUT, DELETE)",
+    )
+    headers: dict[str, str] = Field(
+        default_factory=dict,
+        description="HTTP headers as string key-value pairs",
+    )
+    body: str | None = Field(
+        default=None,
+        description="Request body as string",
+    )
+
+    # File operation fields
+    path: str | None = Field(
+        default=None,
+        description="File system path",
+    )
+    content: str | None = Field(
+        default=None,
+        description="File content for write operations",
+    )
+
+    # Message queue fields
+    queue_name: str | None = Field(
+        default=None,
+        description="Message queue name",
+    )
+    message: str | None = Field(
+        default=None,
+        description="Message content",
+    )
+
+    # Event envelope payload (for event-driven processing)
+    envelope_payload: dict[str, str] = Field(
+        default_factory=dict,
+        description="Event envelope payload data as string key-value pairs",
+    )
+
+
+__all__ = ["ModelOperationData"]
diff --git a/src/omnibase_core/models/common/model_reducer_metadata.py b/src/omnibase_core/models/common/model_reducer_metadata.py
new file mode 100644
index 0000000000..b2a21c25da
--- /dev/null
+++ b/src/omnibase_core/models/common/model_reducer_metadata.py
@@ -0,0 +1,60 @@
+"""
+Typed metadata model for reducer input.
+
+This module provides strongly-typed metadata for reducer patterns.
+"""
+
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelReducerMetadata(BaseModel):
+    """
+    Typed metadata for reducer input.
+
+    Replaces dict[str, Any] metadata field in ModelReducerInput
+    with explicit typed fields for reducer metadata.
+
+    Note: All fields are optional as metadata may be partially populated
+    depending on the source and context. This is intentional for metadata
+    models that aggregate information from multiple sources.
+    """
+
+    model_config = ConfigDict(extra="forbid", from_attributes=True)
+
+    source: str | None = Field(
+        default=None,
+        description="Source identifier",
+    )
+    trace_id: str | None = Field(
+        default=None,
+        description="Distributed tracing identifier",
+    )
+    span_id: str | None = Field(
+        default=None,
+        description="Span identifier for tracing",
+    )
+    correlation_id: str | None = Field(
+        default=None,
+        description="Correlation ID for request tracking",
+    )
+    group_key: str | None = Field(
+        default=None,
+        description="Key for grouping operations",
+    )
+    partition_id: UUID | None = Field(
+        default=None,
+        description="Partition identifier for distributed processing",
+    )
+    window_id: UUID | None = Field(
+        default=None,
+        description="Window identifier for streaming operations",
+    )
+    tags: list[str] = Field(
+        default_factory=list,
+        description="Tags for categorization",
+    )
+
+
+__all__ = ["ModelReducerMetadata"]
diff --git a/src/omnibase_core/models/common/model_request_metadata.py b/src/omnibase_core/models/common/model_request_metadata.py
new file mode 100644
index 0000000000..90efc12d69
--- /dev/null
+++ b/src/omnibase_core/models/common/model_request_metadata.py
@@ -0,0 +1,56 @@
+"""
+Typed metadata model for discovery/effect/reducer requests.
+
+This module provides strongly-typed metadata for request patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from omnibase_core.protocols.base import LiteralEventPriority
+
+
+class ModelRequestMetadata(BaseModel):
+    """
+    Typed metadata for discovery/effect/reducer requests.
+
+    Replaces dict[str, Any] metadata field in request models
+    with explicit typed fields for common request metadata.
+
+    Note: All fields are optional as metadata may be partially populated
+    depending on the source and context. This is intentional for metadata
+    models that aggregate information from multiple sources.
+    """
+
+    model_config = ConfigDict(extra="forbid", from_attributes=True)
+
+    source: str | None = Field(
+        default=None,
+        description="Source identifier of the request",
+    )
+    trace_id: str | None = Field(
+        default=None,
+        description="Distributed tracing identifier",
+    )
+    span_id: str | None = Field(
+        default=None,
+        description="Span identifier for tracing",
+    )
+    user_agent: str | None = Field(
+        default=None,
+        description="User agent making the request",
+    )
+    environment: str | None = Field(
+        default=None,
+        description="Deployment environment (dev, staging, prod)",
+    )
+    priority: LiteralEventPriority | None = Field(
+        default=None,
+        description="Request priority level (low, normal, high, critical)",
+    )
+    tags: list[str] = Field(
+        default_factory=list,
+        description="Tags for request categorization",
+    )
+
+
+__all__ = ["ModelRequestMetadata"]
diff --git a/src/omnibase_core/models/common/model_shutdown_metrics.py b/src/omnibase_core/models/common/model_shutdown_metrics.py
new file mode 100644
index 0000000000..0ef96e30f2
--- /dev/null
+++ b/src/omnibase_core/models/common/model_shutdown_metrics.py
@@ -0,0 +1,63 @@
+"""
+Typed metrics model for node shutdown events.
+
+This module provides strongly-typed metrics for shutdown patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelShutdownMetrics(BaseModel):
+    """
+    Typed metrics for node shutdown events.
+
+    Replaces dict[str, Any] final_metrics field in ModelNodeShutdownEvent
+    with explicit typed fields for shutdown metrics.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        frozen=True,
+        validate_assignment=True,
+    )
+
+    error_message: str | None = Field(
+        default=None,
+        description="Error message if shutdown was due to error",
+    )
+    maintenance_reason: str | None = Field(
+        default=None,
+        description="Reason for maintenance shutdown",
+    )
+    force_reason: str | None = Field(
+        default=None,
+        description="Reason for forced shutdown",
+    )
+    total_requests: int | None = Field(
+        default=None,
+        description="Total requests processed during lifetime",
+        ge=0,
+    )
+    total_errors: int | None = Field(
+        default=None,
+        description="Total errors encountered during lifetime",
+        ge=0,
+    )
+    average_response_time_ms: float | None = Field(
+        default=None,
+        description="Average response time in milliseconds",
+        ge=0.0,
+    )
+    peak_memory_mb: int | None = Field(
+        default=None,
+        description="Peak memory usage in megabytes",
+        ge=0,
+    )
+    cpu_time_seconds: float | None = Field(
+        default=None,
+        description="Total CPU time consumed in seconds",
+        ge=0.0,
+    )
+
+
+__all__ = ["ModelShutdownMetrics"]
diff --git a/src/omnibase_core/models/common/model_tool_metadata_fields.py b/src/omnibase_core/models/common/model_tool_metadata_fields.py
new file mode 100644
index 0000000000..3bde1f88f4
--- /dev/null
+++ b/src/omnibase_core/models/common/model_tool_metadata_fields.py
@@ -0,0 +1,60 @@
+"""
+Typed metadata model for discovered tools.
+
+This module provides strongly-typed metadata for tool discovery patterns.
+"""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelToolMetadataFields(BaseModel):
+    """
+    Typed metadata for discovered tools.
+
+    Replaces dict[str, Any] metadata field in ModelDiscoveredTool
+    with explicit typed fields for common tool metadata.
+
+    Note: All fields are optional as metadata may be partially populated
+    depending on the source and context. This is intentional for metadata
+    models that aggregate information from multiple sources.
+    """
+
+    model_config = ConfigDict(extra="forbid", from_attributes=True)
+
+    author: str | None = Field(
+        default=None,
+        description="Author or maintainer of the tool",
+    )
+    trust_score: float | None = Field(
+        default=None,
+        description="Trust score for the tool (0.0 to 1.0)",
+        ge=0.0,
+        le=1.0,
+    )
+    documentation_url: str | None = Field(
+        default=None,
+        description="URL to tool documentation",
+    )
+    source_repository: str | None = Field(
+        default=None,
+        description="Source code repository URL",
+    )
+    license: str | None = Field(
+        default=None,
+        description="Software license identifier",
+    )
+    category: str | None = Field(
+        default=None,
+        description="Tool category for classification",
+    )
+    capabilities: list[str] = Field(
+        default_factory=list,
+        description="List of tool capabilities",
+    )
+    dependencies: list[str] = Field(
+        default_factory=list,
+        description="List of tool dependencies",
+    )
+
+
+__all__ = ["ModelToolMetadataFields"]
diff --git a/src/omnibase_core/models/common/model_tool_result_data.py b/src/omnibase_core/models/common/model_tool_result_data.py
new file mode 100644
index 0000000000..5fdf7ce7a1
--- /dev/null
+++ b/src/omnibase_core/models/common/model_tool_result_data.py
@@ -0,0 +1,44 @@
+"""
+Typed result data model for tool responses.
+
+This module provides strongly-typed result data for tool response patterns.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class ModelToolResultData(BaseModel):
+    """
+    Typed result data for tool responses.
+
+    Replaces dict[str, Any] result field in ModelToolResponseEvent
+    with explicit typed fields for tool execution results.
+    """
+
+    output: str | None = Field(
+        default=None,
+        description="Tool output content",
+    )
+    status: str | None = Field(
+        default=None,
+        description="Execution status",
+    )
+    artifacts: list[str] = Field(
+        default_factory=list,
+        description="Generated artifact paths or IDs",
+    )
+    warnings: list[str] = Field(
+        default_factory=list,
+        description="Non-fatal warnings during execution",
+    )
+    metrics: dict[str, float] = Field(
+        default_factory=dict,
+        description="Execution metrics",
+    )
+    data_fields: dict[str, str] = Field(
+        default_factory=dict,
+        description="Additional result data as key-value pairs",
+    )
+
+
+__all__ = ["ModelToolResultData"]
diff --git a/src/omnibase_core/models/common/model_typed_metadata.py b/src/omnibase_core/models/common/model_typed_metadata.py
index 00c7d46f32..d9a16a3247 100644
--- a/src/omnibase_core/models/common/model_typed_metadata.py
+++ b/src/omnibase_core/models/common/model_typed_metadata.py
@@ -5,7 +5,7 @@
 found across discovery, effect, reducer, and other model modules.
 """
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 
 class ModelToolMetadataFields(BaseModel):
@@ -189,13 +189,13 @@ class ModelConfigSchemaProperty(BaseModel):
         default=None,
         description="Property description",
     )
-    default: str | None = Field(
+    default: str | int | float | bool | None = Field(
         default=None,
-        description="Default value as string",
+        description="Default value (type should match the 'type' field)",
     )
-    enum: list[str] | None = Field(
+    enum: list[str | int | float | bool | None] | None = Field(
         default=None,
-        description="Allowed values for enum types",
+        description="Allowed enum values (supports strings, numbers, booleans, and null)",
     )
     required: bool = Field(
         default=False,
@@ -232,6 +232,25 @@ class ModelMixinConfigSchema(BaseModel):
         description="Whether additional properties are allowed",
     )
 
+    @model_validator(mode="after")
+    def _validate_required_properties_subset(self) -> "ModelMixinConfigSchema":
+        """Validate that required_properties is a subset of properties keys."""
+        if not self.required_properties:
+            return self
+
+        property_names = set(self.properties.keys())
+        required_set = set(self.required_properties)
+        undefined_required = required_set - property_names
+
+        if undefined_required:
+            raise ValueError(
+                f"required_properties contains undefined properties: "
+                f"{sorted(undefined_required)}. "
+                f"Valid properties are: {sorted(property_names)}"
+            )
+
+        return self
+
 
 class ModelOperationData(BaseModel):
     """
diff --git a/src/omnibase_core/models/core/model_yaml_schema_object.py b/src/omnibase_core/models/core/model_yaml_schema_object.py
index 644fba696e..9c128af903 100644
--- a/src/omnibase_core/models/core/model_yaml_schema_object.py
+++ b/src/omnibase_core/models/core/model_yaml_schema_object.py
@@ -6,7 +6,7 @@
 
 """
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from omnibase_core.models.core.model_yaml_schema_property import ModelYamlSchemaProperty
 
@@ -29,3 +29,22 @@ class ModelYamlSchemaObject(BaseModel):
         description="Required property names",
     )
     description: str = Field(default="", description="Object description")
+
+    @model_validator(mode="after")
+    def _validate_required_properties_subset(self) -> "ModelYamlSchemaObject":
+        """Validate that required_properties is a subset of properties keys."""
+        if not self.required_properties:
+            return self
+
+        property_names = set(self.properties.keys())
+        required_set = set(self.required_properties)
+        undefined_required = required_set - property_names
+
+        if undefined_required:
+            raise ValueError(
+                f"required_properties contains undefined properties: "
+                f"{sorted(undefined_required)}. "
+                f"Valid properties are: {sorted(property_names)}"
+            )
+
+        return self
diff --git a/src/omnibase_core/models/node_metadata/model_node_status_active.py b/src/omnibase_core/models/node_metadata/model_node_status_active.py
index 3c7bc024c0..dbe8101bab 100644
--- a/src/omnibase_core/models/node_metadata/model_node_status_active.py
+++ b/src/omnibase_core/models/node_metadata/model_node_status_active.py
@@ -6,7 +6,7 @@
 
 from pydantic import BaseModel, Field
 
-from omnibase_core.types.typed_dict_status_summaries import TypedDictActiveSummary
+from omnibase_core.types.typed_dict_active_summary import TypedDictActiveSummary
 
 
 class ModelNodeStatusActive(BaseModel):
diff --git a/src/omnibase_core/models/node_metadata/model_node_status_error.py b/src/omnibase_core/models/node_metadata/model_node_status_error.py
index 581acaf50e..aa4a21ea20 100644
--- a/src/omnibase_core/models/node_metadata/model_node_status_error.py
+++ b/src/omnibase_core/models/node_metadata/model_node_status_error.py
@@ -6,7 +6,7 @@
 
 from pydantic import BaseModel, Field
 
-from omnibase_core.types.typed_dict_status_summaries import TypedDictErrorSummary
+from omnibase_core.types.typed_dict_error_summary import TypedDictErrorSummary
 
 
 class ModelNodeStatusError(BaseModel):
diff --git a/src/omnibase_core/models/node_metadata/model_node_status_maintenance.py b/src/omnibase_core/models/node_metadata/model_node_status_maintenance.py
index da5efe9dde..134128c24a 100644
--- a/src/omnibase_core/models/node_metadata/model_node_status_maintenance.py
+++ b/src/omnibase_core/models/node_metadata/model_node_status_maintenance.py
@@ -6,7 +6,9 @@
 
 from pydantic import BaseModel, Field
 
-from omnibase_core.types.typed_dict_status_summaries import TypedDictMaintenanceSummary
+from omnibase_core.types.typed_dict_maintenance_summary import (
+    TypedDictMaintenanceSummary,
+)
 
 
 class ModelNodeStatusMaintenance(BaseModel):
diff --git a/src/omnibase_core/types/__init__.py b/src/omnibase_core/types/__init__.py
index 437f27f4ba..2e81228531 100644
--- a/src/omnibase_core/types/__init__.py
+++ b/src/omnibase_core/types/__init__.py
@@ -91,6 +91,7 @@
 from .typed_dict_access_control_config import TypedDictAccessControlConfig
 from .typed_dict_action_validation_context import TypedDictActionValidationContext
 from .typed_dict_action_validation_statistics import TypedDictActionValidationStatistics
+from .typed_dict_active_summary import TypedDictActiveSummary
 from .typed_dict_additional_fields import TypedDictAdditionalFields
 from .typed_dict_alert_data import TypedDictAlertData
 from .typed_dict_alert_metadata import TypedDictAlertMetadata
@@ -142,6 +143,7 @@
 from .typed_dict_error_analysis import TypedDictErrorAnalysis
 from .typed_dict_error_data import TypedDictErrorData
 from .typed_dict_error_details import TypedDictErrorDetails
+from .typed_dict_error_summary import TypedDictErrorSummary
 from .typed_dict_event_info import TypedDictEventInfo
 from .typed_dict_event_type import TypedDictEventType
 from .typed_dict_execution_stats import TypedDictExecutionStats
@@ -169,6 +171,7 @@
 from .typed_dict_legacy_stats import TypedDictLegacyStats
 from .typed_dict_lifecycle_event_fields import TypedDictLifecycleEventFields
 from .typed_dict_lifecycle_event_metadata import TypedDictLifecycleEventMetadata
+from .typed_dict_maintenance_summary import TypedDictMaintenanceSummary
 
 # YAML and path resolution TypedDict definitions
 from .typed_dict_mapping_result import MappingResultDict
@@ -511,6 +514,10 @@
     "TypedDictNodeCapabilities",
     "TypedDictNodeIntrospection",
     "TypedDictNodeState",
+    # Node status summary TypedDict definitions
+    "TypedDictActiveSummary",
+    "TypedDictErrorSummary",
+    "TypedDictMaintenanceSummary",
     # YAML and path resolution types
     "MappingResultDict",
     "TypedDictPathResolutionContext",
diff --git a/src/omnibase_core/types/typed_dict_active_summary.py b/src/omnibase_core/types/typed_dict_active_summary.py
new file mode 100644
index 0000000000..a0ae5704fd
--- /dev/null
+++ b/src/omnibase_core/types/typed_dict_active_summary.py
@@ -0,0 +1,25 @@
+"""
+TypedDict definition for active status summary.
+
+Strongly-typed structure for active status summary methods.
+"""
+
+from typing import TypedDict
+
+
+class TypedDictActiveSummary(TypedDict):
+    """Typed structure for active status summary."""
+
+    status_type: str
+    uptime_seconds: int
+    uptime_days: float
+    uptime_hours: float
+    uptime_minutes: float
+    last_heartbeat: str
+    is_recent_heartbeat: bool
+    health_score: float
+
+
+__all__ = [
+    "TypedDictActiveSummary",
+]
diff --git a/src/omnibase_core/types/typed_dict_error_summary.py b/src/omnibase_core/types/typed_dict_error_summary.py
new file mode 100644
index 0000000000..e2238443d1
--- /dev/null
+++ b/src/omnibase_core/types/typed_dict_error_summary.py
@@ -0,0 +1,24 @@
+"""
+TypedDict definition for error status summary.
+
+Strongly-typed structure for error status summary methods.
+"""
+
+from typing import TypedDict
+
+
+class TypedDictErrorSummary(TypedDict):
+    """Typed structure for error status summary."""
+
+    status_type: str
+    error_code: str
+    error_message: str
+    has_recovery_suggestion: bool
+    recovery_suggestion: str | None
+    is_critical: bool
+    severity: str
+
+
+__all__ = [
+    "TypedDictErrorSummary",
+]
diff --git a/src/omnibase_core/types/typed_dict_maintenance_summary.py b/src/omnibase_core/types/typed_dict_maintenance_summary.py
new file mode 100644
index 0000000000..8036a945ef
--- /dev/null
+++ b/src/omnibase_core/types/typed_dict_maintenance_summary.py
@@ -0,0 +1,23 @@
+"""
+TypedDict definition for maintenance status summary.
+
+Strongly-typed structure for maintenance status summary methods.
+"""
+
+from typing import TypedDict
+
+
+class TypedDictMaintenanceSummary(TypedDict):
+    """Typed structure for maintenance status summary."""
+
+    status_type: str
+    estimated_completion: str
+    maintenance_reason: str
+    is_critical: bool
+    is_scheduled: bool
+    priority: str
+
+
+__all__ = [
+    "TypedDictMaintenanceSummary",
+]
diff --git a/src/omnibase_core/types/typed_dict_status_summaries.py b/src/omnibase_core/types/typed_dict_status_summaries.py
deleted file mode 100644
index a68ef98b11..0000000000
--- a/src/omnibase_core/types/typed_dict_status_summaries.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""
-TypedDict definitions for node status summary return types.
-
-Strongly-typed structures for status summary methods.
-"""
-
-from typing import TypedDict
-
-
-class TypedDictMaintenanceSummary(TypedDict):
-    """Typed structure for maintenance status summary."""
-
-    status_type: str
-    estimated_completion: str
-    maintenance_reason: str
-    is_critical: bool
-    is_scheduled: bool
-    priority: str
-
-
-class TypedDictErrorSummary(TypedDict):
-    """Typed structure for error status summary."""
-
-    status_type: str
-    error_code: str
-    error_message: str
-    has_recovery_suggestion: bool
-    recovery_suggestion: str | None
-    is_critical: bool
-    severity: str
-
-
-class TypedDictActiveSummary(TypedDict):
-    """Typed structure for active status summary."""
-
-    status_type: str
-    uptime_seconds: int
-    uptime_days: float
-    uptime_hours: float
-    uptime_minutes: float
-    last_heartbeat: str
-    is_recent_heartbeat: bool
-    health_score: float
-
-
-__all__ = [
-    "TypedDictMaintenanceSummary",
-    "TypedDictErrorSummary",
-    "TypedDictActiveSummary",
-]
diff --git a/tests/unit/scripts/test_regenerate_fingerprints.py b/tests/unit/scripts/test_regenerate_fingerprints.py
new file mode 100644
index 0000000000..5d27609496
--- /dev/null
+++ b/tests/unit/scripts/test_regenerate_fingerprints.py
@@ -0,0 +1,1158 @@
+"""
+Comprehensive unit tests for the regenerate_fingerprints.py script.
+
+Tests the fingerprint regeneration script which validates ONEX contracts and
+regenerates fingerprints in-place. This implements PR #180 review requirements
+for fingerprint script validation test coverage.
+
+Test Categories:
+1. Type Validation Tests (default/type mismatches)
+2. Dry-Run Mode Tests
+3. Fingerprint Consistency Tests
+4. Error Handling Tests (malformed YAML)
+5. File Size Limit Tests
+
+Requirements from PR #180 Review:
+- Test that `default=3.5` with `type="integer"` raises error
+- Test that `default="text"` with `type="number"` raises error
+- Test that `default=42` with `type="string"` raises error
+- Test dry-run mode doesn't modify files
+- Test that regenerated fingerprints match `compute_contract_fingerprint()`
+- Test error handling for malformed YAML
+- Test file size limit enforcement
+"""
+
+from __future__ import annotations
+
+import sys
+import tempfile
+from collections.abc import Generator
+from pathlib import Path
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+# Add scripts directory to path for import
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent / "scripts"))
+
+from regenerate_fingerprints import (
+    MAX_FILE_SIZE_BYTES,
+    RegenerateResult,
+    compute_fingerprint_for_contract,
+    detect_contract_model,
+    find_contract_files,
+    regenerate_fingerprint,
+    update_fingerprint_in_yaml,
+)
+
+from omnibase_core.contracts import compute_contract_fingerprint
+from omnibase_core.enums.enum_core_error_code import EnumCoreErrorCode
+from omnibase_core.models.contracts.model_action_config_parameter import (
+    ModelActionConfigParameter,
+)
+from omnibase_core.models.contracts.model_contract_compute import ModelContractCompute
+from omnibase_core.models.errors.model_onex_error import ModelOnexError
+
+# =============================================================================
+# Test Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def temp_dir() -> Generator[Path, None, None]:
+    """Create a temporary directory for test files."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield Path(tmpdir)
+
+
+@pytest.fixture
+def valid_compute_contract_yaml() -> str:
+    """Valid compute contract YAML content with all required fields."""
+    return """
+name: NodeTestCompute
+version:
+  major: 1
+  minor: 0
+  patch: 0
+node_type: COMPUTE_GENERIC
+description: A test compute node for fingerprint testing
+input_model: omnibase_core.models.ModelComputeInput
+output_model: omnibase_core.models.ModelComputeOutput
+dependencies: []
+algorithm:
+  algorithm_type: default
+  factors:
+    default_factor:
+      weight: 1.0
+      calculation_method: identity
+"""
+
+
+@pytest.fixture
+def valid_effect_contract_yaml() -> str:
+    """Valid effect contract YAML content."""
+    return """
+name: NodeTestEffect
+version:
+  major: 1
+  minor: 0
+  patch: 0
+node_type: EFFECT_GENERIC
+description: A test effect node for fingerprint testing
+input_model: omnibase_core.models.ModelEffectInput
+output_model: omnibase_core.models.ModelEffectOutput
+dependencies: []
+"""
+
+
+@pytest.fixture
+def contract_with_existing_fingerprint_yaml() -> str:
+    """Contract with an existing fingerprint field."""
+    return """
+name: NodeFingerprintedCompute
+version:
+  major: 1
+  minor: 0
+  patch: 0
+node_type: COMPUTE_GENERIC
+description: A compute node with existing fingerprint
+input_model: omnibase_core.models.ModelComputeInput
+output_model: omnibase_core.models.ModelComputeOutput
+dependencies: []
+fingerprint: "1.0.0:abcdef123456"
+algorithm:
+  algorithm_type: default
+  factors:
+    default_factor:
+      weight: 1.0
+      calculation_method: identity
+"""
+
+
+@pytest.fixture
+def malformed_yaml_content() -> str:
+    """Malformed YAML content with syntax errors."""
+    return """
+name: BadContract
+version: [invalid: yaml
+  missing: brackets
+"""
+
+
+@pytest.fixture
+def empty_yaml_content() -> str:
+    """Empty YAML content."""
+    return ""
+
+
+@pytest.fixture
+def non_contract_yaml_content() -> str:
+    """YAML that is not an ONEX contract (missing node_type)."""
+    return """
+name: NotAContract
+description: This is not a valid ONEX contract
+some_field: value
+"""
+
+
+# =============================================================================
+# Type Validation Tests (Default/Type Mismatches)
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestTypeValidation:
+    """Tests for type validation of default values.
+
+    These tests verify that the ModelActionConfigParameter model correctly
+    rejects default values that don't match the declared type.
+    """
+
+    def test_float_default_with_integer_type_raises_error(self) -> None:
+        """Test that default=3.5 with type='int' raises validation error.
+
+        PR #180 Requirement: Test that `default=3.5` with `type="integer"` raises error.
+        Note: The actual type is 'int' in the model, not 'integer'.
+        """
+        with pytest.raises(ModelOnexError) as exc_info:
+            ModelActionConfigParameter(
+                name="test_param",
+                type="int",
+                required=False,
+                default=3.5,  # Float value for int type
+                description="Test parameter",
+            )
+
+        assert exc_info.value.error_code == EnumCoreErrorCode.PARAMETER_TYPE_MISMATCH
+        assert "float" in str(exc_info.value.message).lower()
+        assert "int" in str(exc_info.value.message).lower()
+
+    def test_string_default_with_float_type_raises_error(self) -> None:
+        """Test that default='text' with type='float' raises validation error.
+
+        PR #180 Requirement: Test that `default="text"` with `type="number"` raises error.
+        Note: The actual type is 'float' in the model, not 'number'.
+        """
+        with pytest.raises(ModelOnexError) as exc_info:
+            ModelActionConfigParameter(
+                name="test_param",
+                type="float",
+                required=False,
+                default="text",  # String value for float type
+                description="Test parameter",
+            )
+
+        assert exc_info.value.error_code == EnumCoreErrorCode.PARAMETER_TYPE_MISMATCH
+        assert "str" in str(exc_info.value.message).lower()
+        assert "float" in str(exc_info.value.message).lower()
+
+    def test_integer_default_with_string_type_raises_error(self) -> None:
+        """Test that default=42 with type='string' raises validation error.
+
+        PR #180 Requirement: Test that `default=42` with `type="string"` raises error.
+        """
+        with pytest.raises(ModelOnexError) as exc_info:
+            ModelActionConfigParameter(
+                name="test_param",
+                type="string",
+                required=False,
+                default=42,  # Integer value for string type
+                description="Test parameter",
+            )
+
+        assert exc_info.value.error_code == EnumCoreErrorCode.PARAMETER_TYPE_MISMATCH
+        assert "int" in str(exc_info.value.message).lower()
+        assert "string" in str(exc_info.value.message).lower()
+
+    def test_bool_default_with_int_type_raises_error(self) -> None:
+        """Test that boolean default with int type raises error.
+
+        This tests the special case where bool is a subclass of int in Python.
+        """
+        with pytest.raises(ModelOnexError) as exc_info:
+            ModelActionConfigParameter(
+                name="test_param",
+                type="int",
+                required=False,
+                default=True,  # Bool value for int type (special case)
+                description="Test parameter",
+            )
+
+        assert exc_info.value.error_code == EnumCoreErrorCode.PARAMETER_TYPE_MISMATCH
+        assert "bool" in str(exc_info.value.message).lower()
+
+    def test_list_default_with_string_type_raises_error(self) -> None:
+        """Test that list default with string type raises error."""
+        with pytest.raises(ModelOnexError) as exc_info:
+            ModelActionConfigParameter(
+                name="test_param",
+                type="string",
+                required=False,
+                default=["item1", "item2"],  # List value for string type
+                description="Test parameter",
+            )
+
+        assert exc_info.value.error_code == EnumCoreErrorCode.PARAMETER_TYPE_MISMATCH
+        assert "list" in str(exc_info.value.message).lower()
+
+    def test_valid_int_default_with_int_type_succeeds(self) -> None:
+        """Test that valid int default with int type succeeds."""
+        param = ModelActionConfigParameter(
+            name="test_param",
+            type="int",
+            required=False,
+            default=42,
+            description="Test parameter",
+        )
+        assert param.default == 42
+        assert param.type == "int"
+
+    def test_valid_string_default_with_string_type_succeeds(self) -> None:
+        """Test that valid string default with string type succeeds."""
+        param = ModelActionConfigParameter(
+            name="test_param",
+            type="string",
+            required=False,
+            default="hello",
+            description="Test parameter",
+        )
+        assert param.default == "hello"
+        assert param.type == "string"
+
+    def test_valid_float_default_with_float_type_succeeds(self) -> None:
+        """Test that valid float default with float type succeeds."""
+        param = ModelActionConfigParameter(
+            name="test_param",
+            type="float",
+            required=False,
+            default=3.14,
+            description="Test parameter",
+        )
+        assert param.default == 3.14
+        assert param.type == "float"
+
+    def test_int_acceptable_for_float_type(self) -> None:
+        """Test that int is acceptable for float type (widening conversion)."""
+        param = ModelActionConfigParameter(
+            name="test_param",
+            type="float",
+            required=False,
+            default=42,  # Int is acceptable for float
+            description="Test parameter",
+        )
+        assert param.default == 42
+        assert param.type == "float"
+
+
+# =============================================================================
+# Dry-Run Mode Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestDryRunMode:
+    """Tests for dry-run mode functionality.
+
+    PR #180 Requirement: Test dry-run mode doesn't modify files.
+    """
+
+    def test_dry_run_does_not_modify_file(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that dry-run mode does not modify the contract file."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        # Record original content
+        original_content = file_path.read_text()
+
+        # Run regeneration in dry-run mode
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Verify file was not modified
+        new_content = file_path.read_text()
+        assert new_content == original_content
+
+        # Verify result shows change would have been made
+        # (if the contract was missing fingerprint or had wrong one)
+        assert result.file_path == file_path
+        # The result may or may not show changed depending on fingerprint computation
+
+    def test_dry_run_with_existing_fingerprint_does_not_modify(
+        self, temp_dir: Path, contract_with_existing_fingerprint_yaml: str
+    ) -> None:
+        """Test dry-run with existing fingerprint doesn't modify file."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(contract_with_existing_fingerprint_yaml)
+
+        original_content = file_path.read_text()
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # File should not be modified
+        assert file_path.read_text() == original_content
+
+        # Result should indicate this is a dry run (fingerprint may or may not match)
+        assert result.file_path == file_path
+
+    def test_dry_run_shows_what_would_change(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that dry-run shows the intended changes without applying them."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # If fingerprint was computed, old should be None (not in original)
+        # and new should be the computed fingerprint
+        if result.new_fingerprint is not None:
+            assert result.old_fingerprint is None  # Original had no fingerprint
+            assert "1.0.0:" in result.new_fingerprint  # Version prefix
+
+
+# =============================================================================
+# Fingerprint Consistency Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestFingerprintConsistency:
+    """Tests for fingerprint computation consistency.
+
+    PR #180 Requirement: Test that regenerated fingerprints match compute_contract_fingerprint().
+    """
+
+    def test_regenerated_fingerprint_matches_direct_computation(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that fingerprint from regenerate script matches direct computation."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        # Compute fingerprint using regenerate script
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        if result.new_fingerprint is not None and result.error is None:
+            # Parse the YAML and create a model to compute fingerprint directly
+            import yaml
+
+            contract_data = yaml.safe_load(valid_compute_contract_yaml)
+            model_class = detect_contract_model(contract_data)
+            if model_class is not None:
+                # Remove fingerprint if present for comparison
+                data_for_fp = {
+                    k: v for k, v in contract_data.items() if k != "fingerprint"
+                }
+                contract = model_class.model_validate(data_for_fp)
+                direct_fingerprint = compute_contract_fingerprint(contract)
+
+                # Compare fingerprints
+                assert result.new_fingerprint == str(direct_fingerprint)
+
+    def test_fingerprint_deterministic_across_multiple_runs(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that fingerprint is deterministic across multiple regenerations."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        # Run regeneration multiple times
+        results = [regenerate_fingerprint(file_path, dry_run=True) for _ in range(5)]
+
+        # All fingerprints should be identical
+        fingerprints = [r.new_fingerprint for r in results if r.new_fingerprint]
+        if fingerprints:
+            assert all(fp == fingerprints[0] for fp in fingerprints)
+
+    def test_compute_fingerprint_for_contract_consistency(self) -> None:
+        """Test compute_fingerprint_for_contract returns consistent results."""
+        contract_data = {
+            "name": "TestContract",
+            "version": {"major": 1, "minor": 0, "patch": 0},
+            "node_type": "COMPUTE_GENERIC",
+            "description": "Test contract",
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "dependencies": [],
+            "algorithm": {
+                "algorithm_type": "default",
+                "factors": {
+                    "default_factor": {
+                        "weight": 1.0,
+                        "calculation_method": "identity",
+                    }
+                },
+            },
+        }
+
+        # Compute multiple times
+        fingerprints = [
+            compute_fingerprint_for_contract(contract_data) for _ in range(5)
+        ]
+
+        # Filter out None results and check consistency
+        valid_fingerprints = [fp for fp in fingerprints if fp is not None]
+        if valid_fingerprints:
+            first = str(valid_fingerprints[0])
+            assert all(str(fp) == first for fp in valid_fingerprints)
+
+
+# =============================================================================
+# Error Handling Tests (Malformed YAML)
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestMalformedYAMLHandling:
+    """Tests for error handling with malformed YAML.
+
+    PR #180 Requirement: Test error handling for malformed YAML.
+    """
+
+    def test_malformed_yaml_returns_error_result(
+        self, temp_dir: Path, malformed_yaml_content: str
+    ) -> None:
+        """Test that malformed YAML returns an error result, not exception."""
+        file_path = temp_dir / "malformed.yaml"
+        file_path.write_text(malformed_yaml_content)
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Should return error result, not raise exception
+        assert result.error is not None
+        assert "YAML" in result.error or "parse" in result.error.lower()
+        assert result.changed is False
+        assert result.new_fingerprint is None
+
+    def test_empty_yaml_returns_skip_result(
+        self, temp_dir: Path, empty_yaml_content: str
+    ) -> None:
+        """Test that empty YAML is handled gracefully."""
+        file_path = temp_dir / "empty.yaml"
+        file_path.write_text(empty_yaml_content)
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Empty YAML should be skipped (not a contract)
+        assert result.skipped is True or result.error is not None
+        assert result.changed is False
+
+    def test_non_contract_yaml_skipped(
+        self, temp_dir: Path, non_contract_yaml_content: str
+    ) -> None:
+        """Test that YAML without node_type is skipped."""
+        file_path = temp_dir / "non_contract.yaml"
+        file_path.write_text(non_contract_yaml_content)
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Should be skipped as it's not an ONEX contract
+        assert result.skipped is True
+        assert result.skip_reason is not None
+        assert "node_type" in result.skip_reason.lower()
+
+    def test_yaml_list_instead_of_dict_handled(self, temp_dir: Path) -> None:
+        """Test that YAML containing a list instead of dict is handled."""
+        file_path = temp_dir / "list.yaml"
+        file_path.write_text("- item1\n- item2\n- item3")
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Should be skipped as it's not a mapping
+        assert result.skipped is True
+        assert "mapping" in result.skip_reason.lower() if result.skip_reason else True
+
+    def test_unicode_error_handled(self, temp_dir: Path) -> None:
+        """Test that files with encoding errors are handled gracefully."""
+        file_path = temp_dir / "binary.yaml"
+        # Write binary content that will cause encoding error
+        file_path.write_bytes(b"\x80\x81\x82\x83")
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Should return error result
+        assert result.error is not None
+        assert "encoding" in result.error.lower() or "decode" in result.error.lower()
+
+
+# =============================================================================
+# File Size Limit Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestFileSizeLimit:
+    """Tests for file size limit enforcement.
+
+    PR #180 Requirement: Test file size limit enforcement.
+    """
+
+    def test_file_size_limit_constant_is_10mb(self) -> None:
+        """Test that MAX_FILE_SIZE_BYTES is set to 10MB."""
+        assert MAX_FILE_SIZE_BYTES == 10 * 1024 * 1024  # 10MB
+
+    def test_large_file_returns_error(self, temp_dir: Path) -> None:
+        """Test that files exceeding size limit return error."""
+        file_path = temp_dir / "large.yaml"
+
+        # Create a file that appears large using mock
+        # We don't actually create a 10MB file for test efficiency
+        file_path.write_text("name: Test")
+
+        # Get the real stat result first
+        real_stat = file_path.stat()
+
+        # Create a mock stat result with large file size
+        class MockStatResult:
+            """Mock stat result with configurable size."""
+
+            st_mode = real_stat.st_mode
+            st_ino = real_stat.st_ino
+            st_dev = real_stat.st_dev
+            st_nlink = real_stat.st_nlink
+            st_uid = real_stat.st_uid
+            st_gid = real_stat.st_gid
+            st_size = MAX_FILE_SIZE_BYTES + 1  # Exceed limit
+            st_atime = real_stat.st_atime
+            st_mtime = real_stat.st_mtime
+            st_ctime = real_stat.st_ctime
+
+        # Mock the stat call to simulate large file
+        with patch.object(Path, "stat", return_value=MockStatResult()):
+            result = regenerate_fingerprint(file_path, dry_run=True)
+
+            assert result.error is not None
+            assert "too large" in result.error.lower() or "size" in result.error.lower()
+
+    def test_normal_size_file_not_rejected(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that normal-sized files are not rejected."""
+        file_path = temp_dir / "normal.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Should not have size-related error
+        if result.error:
+            assert "too large" not in result.error.lower()
+            assert "size" not in result.error.lower()
+
+
+# =============================================================================
+# File Discovery Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestFileDiscovery:
+    """Tests for contract file discovery functionality."""
+
+    def test_find_yaml_files(self, temp_dir: Path) -> None:
+        """Test finding YAML files in a directory."""
+        (temp_dir / "contract1.yaml").write_text("node_type: COMPUTE_GENERIC")
+        (temp_dir / "contract2.yml").write_text("node_type: EFFECT_GENERIC")
+        (temp_dir / "not_yaml.txt").write_text("not yaml")
+
+        files = find_contract_files(temp_dir)
+
+        assert len(files) == 2
+        assert any(f.name == "contract1.yaml" for f in files)
+        assert any(f.name == "contract2.yml" for f in files)
+
+    def test_find_yaml_files_recursive(self, temp_dir: Path) -> None:
+        """Test recursive file discovery."""
+        subdir = temp_dir / "subdir"
+        subdir.mkdir()
+        (temp_dir / "root.yaml").write_text("node_type: COMPUTE_GENERIC")
+        (subdir / "nested.yaml").write_text("node_type: EFFECT_GENERIC")
+
+        files = find_contract_files(temp_dir, recursive=True)
+
+        assert len(files) == 2
+
+    def test_excludes_special_directories(self, temp_dir: Path) -> None:
+        """Test that __pycache__, .git, etc. are excluded."""
+        pycache = temp_dir / "__pycache__"
+        pycache.mkdir()
+        (pycache / "cached.yaml").write_text("node_type: COMPUTE_GENERIC")
+
+        git = temp_dir / ".git"
+        git.mkdir()
+        (git / "config.yaml").write_text("git: true")
+
+        venv = temp_dir / ".venv"
+        venv.mkdir()
+        (venv / "package.yaml").write_text("venv: true")
+
+        (temp_dir / "valid.yaml").write_text("node_type: COMPUTE_GENERIC")
+
+        files = find_contract_files(temp_dir, recursive=True)
+
+        assert len(files) == 1
+        assert files[0].name == "valid.yaml"
+
+
+# =============================================================================
+# YAML Fingerprint Update Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestUpdateFingerprintInYAML:
+    """Tests for updating fingerprint in YAML content."""
+
+    def test_update_existing_fingerprint(self) -> None:
+        """Test updating an existing fingerprint in YAML."""
+        content = """name: Test
+version: "1.0.0"
+fingerprint: "1.0.0:oldvalue1234"
+description: Test
+"""
+        new_fp = "1.0.0:newvalue5678"
+
+        updated = update_fingerprint_in_yaml(content, new_fp)
+
+        assert 'fingerprint: "1.0.0:newvalue5678"' in updated
+        assert "oldvalue1234" not in updated
+
+    def test_add_fingerprint_after_version(self) -> None:
+        """Test adding fingerprint after version field when not present."""
+        content = """name: Test
+version: "1.0.0"
+description: Test
+"""
+        new_fp = "1.0.0:abcdef123456"
+
+        updated = update_fingerprint_in_yaml(content, new_fp)
+
+        assert 'fingerprint: "1.0.0:abcdef123456"' in updated
+        # Fingerprint should be after version
+        version_pos = updated.find("version:")
+        fingerprint_pos = updated.find("fingerprint:")
+        assert fingerprint_pos > version_pos
+
+
+# =============================================================================
+# Contract Model Detection Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestContractModelDetection:
+    """Tests for contract model detection."""
+
+    def test_detect_compute_model(self) -> None:
+        """Test detecting compute contract model."""
+        data = {
+            "node_type": "COMPUTE_GENERIC",
+            "name": "TestCompute",
+            "version": "1.0.0",
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "description": "Test",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model == ModelContractCompute
+
+    def test_detect_effect_model(self) -> None:
+        """Test detecting effect contract model."""
+        from omnibase_core.models.contracts.model_contract_effect import (
+            ModelContractEffect,
+        )
+
+        data = {
+            "node_type": "EFFECT_GENERIC",
+            "name": "TestEffect",
+            "version": "1.0.0",
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "description": "Test",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model == ModelContractEffect
+
+    def test_detect_fallback_to_yaml_contract(self) -> None:
+        """Test fallback to ModelYamlContract for unknown types."""
+        from omnibase_core.models.contracts.model_yaml_contract import ModelYamlContract
+
+        data = {
+            "node_type": "UNKNOWN_TYPE",
+            "name": "TestUnknown",
+        }
+
+        model = detect_contract_model(data)
+
+        # Should fall back to flexible model
+        assert model is not None
+
+    def test_missing_node_type_returns_none(self) -> None:
+        """Test that missing node_type returns None."""
+        data = {
+            "name": "TestNoNodeType",
+            "version": "1.0.0",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model is None
+
+
+# =============================================================================
+# RegenerateResult Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestRegenerateResult:
+    """Tests for RegenerateResult data class."""
+
+    def test_result_to_dict_serialization(self, temp_dir: Path) -> None:
+        """Test RegenerateResult serialization to dictionary."""
+        result = RegenerateResult(
+            file_path=temp_dir / "test.yaml",
+            old_fingerprint="1.0.0:old12345678",
+            new_fingerprint="1.0.0:new12345678",
+            changed=True,
+        )
+
+        d = result.to_dict()
+
+        assert "file" in d
+        assert d["old_fingerprint"] == "1.0.0:old12345678"
+        assert d["new_fingerprint"] == "1.0.0:new12345678"
+        assert d["changed"] is True
+        assert d["error"] is None
+        assert d["skipped"] is False
+
+    def test_result_with_error(self, temp_dir: Path) -> None:
+        """Test RegenerateResult with error."""
+        result = RegenerateResult(
+            file_path=temp_dir / "error.yaml",
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            error="File not found",
+        )
+
+        assert result.error == "File not found"
+        assert result.changed is False
+
+    def test_result_skipped(self, temp_dir: Path) -> None:
+        """Test RegenerateResult when skipped."""
+        result = RegenerateResult(
+            file_path=temp_dir / "skipped.yaml",
+            old_fingerprint=None,
+            new_fingerprint=None,
+            changed=False,
+            skipped=True,
+            skip_reason="Not an ONEX contract",
+        )
+
+        assert result.skipped is True
+        assert result.skip_reason == "Not an ONEX contract"
+
+
+# =============================================================================
+# Edge Case Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestEdgeCases:
+    """Tests for edge cases and boundary conditions."""
+
+    def test_nonexistent_file_returns_error(self, temp_dir: Path) -> None:
+        """Test that nonexistent file returns error result."""
+        file_path = temp_dir / "nonexistent.yaml"
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        assert result.error is not None
+        assert "not found" in result.error.lower() or "not found" in result.error
+
+    def test_directory_instead_of_file_returns_error(self, temp_dir: Path) -> None:
+        """Test that passing a directory returns error."""
+        dir_path = temp_dir / "subdir"
+        dir_path.mkdir()
+
+        result = regenerate_fingerprint(dir_path, dry_run=True)
+
+        assert result.error is not None
+        assert "not a file" in result.error.lower() or "file" in result.error.lower()
+
+    def test_whitespace_only_yaml(self, temp_dir: Path) -> None:
+        """Test handling of whitespace-only YAML files."""
+        file_path = temp_dir / "whitespace.yaml"
+        file_path.write_text("   \n\t\n   ")
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        # Should be skipped or error (empty content)
+        assert result.skipped or result.error is not None
+
+    def test_fingerprint_format_preserved(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that fingerprint format is correct (version:hash)."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        result = regenerate_fingerprint(file_path, dry_run=True)
+
+        if result.new_fingerprint:
+            # Should be in format "version:hash"
+            assert ":" in result.new_fingerprint
+            version, hash_part = result.new_fingerprint.split(":", 1)
+            assert version == "1.0.0"  # From contract version
+            assert len(hash_part) == 12  # Default hash length
+
+
+# =============================================================================
+# Non-Dry-Run (Actual Write) Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestActualWrite:
+    """Tests for actual file modification (non-dry-run mode)."""
+
+    def test_regenerate_actually_modifies_file(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that non-dry-run mode actually modifies the file."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        original_content = file_path.read_text()
+
+        # Run without dry-run
+        result = regenerate_fingerprint(file_path, dry_run=False)
+
+        new_content = file_path.read_text()
+
+        # If fingerprint was computed, file should be modified
+        if result.new_fingerprint and result.changed:
+            assert new_content != original_content
+            assert "fingerprint:" in new_content
+            assert result.new_fingerprint in new_content
+
+    def test_regenerate_adds_fingerprint_to_file_without_one(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that fingerprint is added to a file that doesn't have one."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        # Verify original has no fingerprint
+        assert "fingerprint:" not in file_path.read_text()
+
+        result = regenerate_fingerprint(file_path, dry_run=False)
+
+        if result.new_fingerprint and not result.error:
+            # File should now have fingerprint
+            new_content = file_path.read_text()
+            assert "fingerprint:" in new_content
+
+    def test_regenerate_updates_existing_fingerprint(
+        self, temp_dir: Path, contract_with_existing_fingerprint_yaml: str
+    ) -> None:
+        """Test that existing fingerprint is updated with correct value."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(contract_with_existing_fingerprint_yaml)
+
+        # The existing fingerprint is "1.0.0:abcdef123456" which is wrong
+        result = regenerate_fingerprint(file_path, dry_run=False)
+
+        if result.new_fingerprint and result.changed:
+            new_content = file_path.read_text()
+            # Old fingerprint should be gone
+            assert "abcdef123456" not in new_content
+            # New fingerprint should be present
+            assert result.new_fingerprint in new_content
+
+
+# =============================================================================
+# Additional Model Detection Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestAdditionalModelDetection:
+    """Additional tests for contract model detection covering more node types."""
+
+    def test_detect_reducer_model(self) -> None:
+        """Test detecting reducer contract model."""
+        from omnibase_core.models.contracts.model_contract_reducer import (
+            ModelContractReducer,
+        )
+
+        data = {
+            "node_type": "REDUCER_GENERIC",
+            "name": "TestReducer",
+            "version": "1.0.0",
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "description": "Test",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model == ModelContractReducer
+
+    def test_detect_orchestrator_model(self) -> None:
+        """Test detecting orchestrator contract model."""
+        from omnibase_core.models.contracts.model_contract_orchestrator import (
+            ModelContractOrchestrator,
+        )
+
+        data = {
+            "node_type": "ORCHESTRATOR_GENERIC",
+            "name": "TestOrchestrator",
+            "version": "1.0.0",
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "description": "Test",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model == ModelContractOrchestrator
+
+    def test_detect_transformer_model(self) -> None:
+        """Test detecting transformer (compute) contract model."""
+        data = {
+            "node_type": "TRANSFORMER",
+            "name": "TestTransformer",
+            "version": "1.0.0",
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "description": "Test",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model == ModelContractCompute
+
+    def test_detect_gateway_model(self) -> None:
+        """Test detecting gateway (effect) contract model."""
+        from omnibase_core.models.contracts.model_contract_effect import (
+            ModelContractEffect,
+        )
+
+        data = {
+            "node_type": "GATEWAY",
+            "name": "TestGateway",
+            "version": "1.0.0",
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "description": "Test",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model == ModelContractEffect
+
+    def test_detect_with_contract_version_uses_yaml_contract(self) -> None:
+        """Test that contracts with contract_version use ModelYamlContract."""
+        from omnibase_core.models.contracts.model_yaml_contract import ModelYamlContract
+
+        data = {
+            "node_type": "COMPUTE_GENERIC",
+            "name": "TestFlexible",
+            "contract_version": "1.0",  # This triggers flexible mode
+            "description": "Test",
+        }
+
+        model = detect_contract_model(data)
+
+        # Should fall back to flexible ModelYamlContract
+        assert model == ModelYamlContract
+
+    def test_non_string_node_type_returns_none(self) -> None:
+        """Test that non-string node_type returns None."""
+        data = {
+            "node_type": 123,  # Not a string
+            "name": "TestBadType",
+        }
+
+        model = detect_contract_model(data)
+
+        assert model is None
+
+
+# =============================================================================
+# Additional YAML Update Tests
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestAdditionalYAMLUpdate:
+    """Additional tests for YAML fingerprint updating."""
+
+    def test_add_fingerprint_without_version_field(self) -> None:
+        """Test adding fingerprint when no version field exists."""
+        content = """name: Test
+description: No version field
+node_type: COMPUTE_GENERIC
+"""
+        new_fp = "0.0.0:abcdef123456"
+
+        updated = update_fingerprint_in_yaml(content, new_fp)
+
+        # Should add fingerprint at the end
+        assert 'fingerprint: "0.0.0:abcdef123456"' in updated
+
+    def test_update_fingerprint_preserves_formatting(self) -> None:
+        """Test that updating fingerprint preserves YAML formatting."""
+        content = """name: Test
+version: "1.0.0"
+fingerprint: "1.0.0:oldvalue1234"
+description: Test description
+  with multiple lines
+"""
+        new_fp = "1.0.0:newvalue5678"
+
+        updated = update_fingerprint_in_yaml(content, new_fp)
+
+        # Check formatting is preserved
+        assert "name: Test" in updated
+        assert 'version: "1.0.0"' in updated
+        assert "description: Test description" in updated
+        assert "with multiple lines" in updated
+
+    def test_update_fingerprint_with_quoted_value(self) -> None:
+        """Test updating fingerprint that has quoted value."""
+        content = """name: Test
+fingerprint: '1.0.0:oldvalue1234'
+"""
+        new_fp = "1.0.0:newvalue5678"
+
+        updated = update_fingerprint_in_yaml(content, new_fp)
+
+        assert 'fingerprint: "1.0.0:newvalue5678"' in updated
+        assert "oldvalue1234" not in updated
+
+
+# =============================================================================
+# Fingerprint Computation Edge Cases
+# =============================================================================
+
+
+@pytest.mark.unit
+class TestFingerprintComputationEdgeCases:
+    """Edge case tests for fingerprint computation."""
+
+    def test_compute_fingerprint_with_schema_validation_error(self) -> None:
+        """Test that schema validation errors are handled gracefully."""
+        # Create contract data that will fail schema validation
+        contract_data = {
+            "node_type": "COMPUTE_GENERIC",
+            "name": "TestBadContract",
+            "version": "invalid_version",  # Invalid version format
+            "input_model": "ModelInput",
+            "output_model": "ModelOutput",
+            "description": "Test",
+        }
+
+        fingerprint = compute_fingerprint_for_contract(contract_data)
+
+        # Should return None on validation error (not raise)
+        # Note: actual behavior depends on implementation
+        # This test documents expected behavior
+
+    def test_compute_fingerprint_with_missing_required_fields(self) -> None:
+        """Test fingerprint computation with missing required fields."""
+        contract_data = {
+            "node_type": "COMPUTE_GENERIC",
+            "name": "TestMinimal",
+            # Missing other required fields
+        }
+
+        fingerprint = compute_fingerprint_for_contract(contract_data)
+
+        # Should return None or handle gracefully
+
+    def test_fingerprint_result_changed_is_false_when_matches(
+        self, temp_dir: Path, valid_compute_contract_yaml: str
+    ) -> None:
+        """Test that changed is False when fingerprint already matches."""
+        file_path = temp_dir / "contract.yaml"
+        file_path.write_text(valid_compute_contract_yaml)
+
+        # First regeneration to add fingerprint
+        result1 = regenerate_fingerprint(file_path, dry_run=False)
+
+        if result1.new_fingerprint and not result1.error:
+            # Second regeneration should show no change
+            result2 = regenerate_fingerprint(file_path, dry_run=True)
+
+            # Should not be changed (fingerprint already correct)
+            assert result2.changed is False
+            assert result2.new_fingerprint == result1.new_fingerprint