diff --git a/pkg/workflows/ring/factory.go b/pkg/workflows/ring/factory.go
index 8b85d02c8..5e8710f9d 100644
--- a/pkg/workflows/ring/factory.go
+++ b/pkg/workflows/ring/factory.go
@@ -4,11 +4,13 @@ import (
 	"context"
 	"errors"
 
+	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
+
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 	"github.com/smartcontractkit/chainlink-common/pkg/services"
 	"github.com/smartcontractkit/chainlink-common/pkg/types/core"
 	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
-	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/shardorchestrator"
 )
 
 const (
@@ -20,15 +22,16 @@ const (
 var _ core.OCR3ReportingPluginFactory = &Factory{}
 
 type Factory struct {
-	store         *Store
-	arbiterScaler pb.ArbiterScalerClient
-	config        *ConsensusConfig
-	lggr          logger.Logger
+	ringStore              *Store
+	shardOrchestratorStore *shardorchestrator.Store
+	arbiterScaler          pb.ArbiterScalerClient
+	config                 *ConsensusConfig
+	lggr                   logger.Logger
 
 	services.StateMachine
 }
 
-func NewFactory(s *Store, arbiterScaler pb.ArbiterScalerClient, lggr logger.Logger, cfg *ConsensusConfig) (*Factory, error) {
+func NewFactory(s *Store, shardOrchestratorStore *shardorchestrator.Store, arbiterScaler pb.ArbiterScalerClient, lggr logger.Logger, cfg *ConsensusConfig) (*Factory, error) {
 	if arbiterScaler == nil {
 		return nil, errors.New("arbiterScaler is required")
 	}
@@ -38,15 +41,16 @@ func NewFactory(s *Store, arbiterScaler pb.ArbiterScalerClient, lggr logger.Logg
 		}
 	}
 	return &Factory{
-		store:         s,
-		arbiterScaler: arbiterScaler,
-		config:        cfg,
-		lggr:          logger.Named(lggr, "RingPluginFactory"),
+		ringStore:              s,
+		shardOrchestratorStore: shardOrchestratorStore,
+		arbiterScaler:          arbiterScaler,
+		config:                 cfg,
+		lggr:                   logger.Named(lggr, "RingPluginFactory"),
 	}, nil
 }
 
 func (o *Factory) NewReportingPlugin(_ context.Context, config ocr3types.ReportingPluginConfig) (ocr3types.ReportingPlugin[[]byte], ocr3types.ReportingPluginInfo, error) {
-	plugin, err := NewPlugin(o.store, o.arbiterScaler, config, o.lggr, o.config)
+	plugin, err := NewPlugin(o.ringStore, o.arbiterScaler, config, o.lggr, o.config)
 	pluginInfo := ocr3types.ReportingPluginInfo{
 		Name: "RingPlugin",
 		Limits: ocr3types.ReportingPluginLimits{
diff --git a/pkg/workflows/ring/factory_test.go b/pkg/workflows/ring/factory_test.go
index 5a81c2a0f..44863d68f 100644
--- a/pkg/workflows/ring/factory_test.go
+++ b/pkg/workflows/ring/factory_test.go
@@ -4,9 +4,10 @@ import (
 	"context"
 	"testing"
 
-	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
 	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 )
 
 func TestFactory_NewFactory(t *testing.T) {
@@ -15,20 +16,20 @@ func TestFactory_NewFactory(t *testing.T) {
 	arbiter := &mockArbiter{}
 
 	t.Run("with_nil_config", func(t *testing.T) {
-		f, err := NewFactory(store, arbiter, lggr, nil)
+		f, err := NewFactory(store, nil, arbiter, lggr, nil)
 		require.NoError(t, err)
 		require.NotNil(t, f)
 	})
 
 	t.Run("with_custom_config", func(t *testing.T) {
 		cfg := &ConsensusConfig{BatchSize: 50}
-		f, err := NewFactory(store, arbiter, lggr, cfg)
+		f, err := NewFactory(store, nil, arbiter, lggr, cfg)
 		require.NoError(t, err)
 		require.NotNil(t, f)
 	})
 
 	t.Run("nil_arbiter_returns_error", func(t *testing.T) {
-		_, err := NewFactory(store, nil, lggr, nil)
+		_, err := NewFactory(store, nil, nil, lggr, nil)
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "arbiterScaler is required")
 	})
@@ -37,7 +38,7 @@ func TestFactory_NewFactory(t *testing.T) {
 func TestFactory_NewReportingPlugin(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
-	f, err := NewFactory(store, &mockArbiter{}, lggr, nil)
+	f, err := NewFactory(store, nil, &mockArbiter{}, lggr, nil)
 	require.NoError(t, err)
 
 	config := ocr3types.ReportingPluginConfig{N: 4, F: 1}
@@ -52,7 +53,7 @@ func TestFactory_NewReportingPlugin(t *testing.T) {
 func TestFactory_Lifecycle(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
-	f, err := NewFactory(store, &mockArbiter{}, lggr, nil)
+	f, err := NewFactory(store, nil, &mockArbiter{}, lggr, nil)
 	require.NoError(t, err)
 
 	err = f.Start(context.Background())
diff --git a/pkg/workflows/ring/pb/generate.go b/pkg/workflows/ring/pb/generate.go
index 850f3eeb4..bff63fddd 100644
--- a/pkg/workflows/ring/pb/generate.go
+++ b/pkg/workflows/ring/pb/generate.go
@@ -1,6 +1,5 @@
 //go:generate protoc --go_out=. --go_opt=paths=source_relative shared.proto
 //go:generate protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative arbiter.proto
-//go:generate protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative shard_orchestrator.proto
 //go:generate protoc --go_out=. --go_opt=paths=source_relative consensus.proto
 
 package pb
diff --git a/pkg/workflows/ring/plugin_test.go b/pkg/workflows/ring/plugin_test.go
index 99f70d1b9..bd4a86d97 100644
--- a/pkg/workflows/ring/plugin_test.go
+++ b/pkg/workflows/ring/plugin_test.go
@@ -12,10 +12,11 @@ import (
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
-	"github.com/smartcontractkit/chainlink-common/pkg/logger"
-	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
 	"github.com/smartcontractkit/libocr/offchainreporting2/types"
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
 )
 
 type mockArbiter struct {
@@ -443,7 +444,7 @@ func TestPlugin_NoHealthyShardsFallbackToShardZero(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	transmitter := NewTransmitter(lggr, store, arbiter, "test-account")
+	transmitter := NewTransmitter(lggr, store, nil, arbiter, "test-account")
 
 	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
 	defer cancel()
diff --git a/pkg/workflows/ring/transmitter.go b/pkg/workflows/ring/transmitter.go
index 524be65be..d45803b60 100644
--- a/pkg/workflows/ring/transmitter.go
+++ b/pkg/workflows/ring/transmitter.go
@@ -5,24 +5,33 @@ import (
 
 	"google.golang.org/protobuf/proto"
 
-	"github.com/smartcontractkit/chainlink-common/pkg/logger"
-	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/types"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/shardorchestrator"
 )
 
 var _ ocr3types.ContractTransmitter[[]byte] = (*Transmitter)(nil)
 
 // Transmitter handles transmission of shard orchestration outcomes
 type Transmitter struct {
-	lggr          logger.Logger
-	store         *Store
-	arbiterScaler pb.ArbiterScalerClient
-	fromAccount   types.Account
+	lggr                   logger.Logger
+	ringStore              *Store
+	shardOrchestratorStore *shardorchestrator.Store
+	arbiterScaler          pb.ArbiterScalerClient
+	fromAccount            types.Account
 }
 
-func NewTransmitter(lggr logger.Logger, store *Store, arbiterScaler pb.ArbiterScalerClient, fromAccount types.Account) *Transmitter {
-	return &Transmitter{lggr: lggr, store: store, arbiterScaler: arbiterScaler, fromAccount: fromAccount}
+func NewTransmitter(lggr logger.Logger, ringStore *Store, shardOrchestratorStore *shardorchestrator.Store, arbiterScaler pb.ArbiterScalerClient, fromAccount types.Account) *Transmitter {
+	return &Transmitter{
+		lggr:                   lggr,
+		ringStore:              ringStore,
+		shardOrchestratorStore: shardOrchestratorStore,
+		arbiterScaler:          arbiterScaler,
+		fromAccount:            fromAccount,
+	}
 }
 
 func (t *Transmitter) Transmit(ctx context.Context, _ types.ConfigDigest, _ uint64, r ocr3types.ReportWithInfo[[]byte], _ []types.AttributedOnchainSignature) error {
@@ -37,10 +46,63 @@ func (t *Transmitter) Transmit(ctx context.Context, _ types.ConfigDigest, _ uint
 		return err
 	}
 
-	t.store.SetRoutingState(outcome.State)
+	// Update Ring Store
+	t.ringStore.SetRoutingState(outcome.State)
+
+	// Determine if system is in transition state
+	systemInTransition := false
+	if outcome.State != nil {
+		if _, ok := outcome.State.State.(*pb.RoutingState_Transition); ok {
+			systemInTransition = true
+		}
+	}
+
+	// Update ShardOrchestrator store if available
+	if t.shardOrchestratorStore != nil {
+		mappings := make([]*shardorchestrator.WorkflowMappingState, 0, len(outcome.Routes))
+		for workflowID, route := range outcome.Routes {
+			// Get the current shard assignment for this workflow to detect changes
+			var oldShardID uint32
+			var transitionState string
+
+			existingMapping, err := t.shardOrchestratorStore.GetWorkflowMapping(ctx, workflowID)
+			if err != nil {
+				// New workflow - no previous assignment
+				oldShardID = 0
+				transitionState = "steady"
+			} else if existingMapping.NewShardID != route.Shard {
+				// Workflow is moving to a different shard
+				oldShardID = existingMapping.NewShardID
+				transitionState = "transitioning"
+			} else {
+				// Same shard - but might be in system transition
+				oldShardID = existingMapping.NewShardID
+				if systemInTransition {
+					transitionState = "transitioning"
+				} else {
+					transitionState = "steady"
+				}
+			}
+
+			mappings = append(mappings, &shardorchestrator.WorkflowMappingState{
+				WorkflowID:      workflowID,
+				OldShardID:      oldShardID,
+				NewShardID:      route.Shard,
+				TransitionState: transitionState,
+			})
+		}
+
+		if err := t.shardOrchestratorStore.BatchUpdateWorkflowMappings(ctx, mappings); err != nil {
+			t.lggr.Errorw("failed to update ShardOrchestrator store", "err", err, "workflowCount", len(mappings))
+			// Don't fail the entire transmission if ShardOrchestrator update fails
+		} else {
+			t.lggr.Debugw("Updated ShardOrchestrator store", "workflowCount", len(mappings))
+		}
+	}
 
+	// Update Ring Store workflow mappings
 	for workflowID, route := range outcome.Routes {
-		t.store.SetShardForWorkflow(workflowID, route.Shard)
+		t.ringStore.SetShardForWorkflow(workflowID, route.Shard)
 		t.lggr.Debugw("Updated workflow shard mapping", "workflowID", workflowID, "shard", route.Shard)
 	}
 
diff --git a/pkg/workflows/ring/transmitter_test.go b/pkg/workflows/ring/transmitter_test.go
index 9fde00015..087f4aaf5 100644
--- a/pkg/workflows/ring/transmitter_test.go
+++ b/pkg/workflows/ring/transmitter_test.go
@@ -9,10 +9,11 @@ import (
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/emptypb"
 
-	"github.com/smartcontractkit/chainlink-common/pkg/logger"
-	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
 	"github.com/smartcontractkit/libocr/offchainreporting2plus/types"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
 )
 
 type mockArbiterScaler struct {
@@ -37,14 +38,14 @@ func (m *mockArbiterScaler) ConsensusWantShards(ctx context.Context, req *pb.Con
 func TestTransmitter_NewTransmitter(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
-	tx := NewTransmitter(lggr, store, nil, "test-account")
+	tx := NewTransmitter(lggr, store, nil, nil, "test-account")
 	require.NotNil(t, tx)
 }
 
 func TestTransmitter_FromAccount(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
-	tx := NewTransmitter(lggr, store, nil, "my-account")
+	tx := NewTransmitter(lggr, store, nil, nil, "my-account")
 
 	account, err := tx.FromAccount(context.Background())
 	require.NoError(t, err)
@@ -55,7 +56,7 @@ func TestTransmitter_Transmit(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
 	mock := &mockArbiterScaler{}
-	tx := NewTransmitter(lggr, store, mock, "test-account")
+	tx := NewTransmitter(lggr, store, nil, mock, "test-account")
 
 	outcome := &pb.Outcome{
 		State: &pb.RoutingState{
@@ -88,7 +89,7 @@ func TestTransmitter_Transmit(t *testing.T) {
 func TestTransmitter_Transmit_NilArbiter(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
-	tx := NewTransmitter(lggr, store, nil, "test-account")
+	tx := NewTransmitter(lggr, store, nil, nil, "test-account")
 
 	outcome := &pb.Outcome{
 		State: &pb.RoutingState{
@@ -107,7 +108,7 @@ func TestTransmitter_Transmit_TransitionState(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
 	mock := &mockArbiterScaler{}
-	tx := NewTransmitter(lggr, store, mock, "test-account")
+	tx := NewTransmitter(lggr, store, nil, mock, "test-account")
 
 	outcome := &pb.Outcome{
 		State: &pb.RoutingState{
@@ -127,7 +128,7 @@ func TestTransmitter_Transmit_TransitionState(t *testing.T) {
 func TestTransmitter_Transmit_InvalidReport(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
-	tx := NewTransmitter(lggr, store, nil, "test-account")
+	tx := NewTransmitter(lggr, store, nil, nil, "test-account")
 
 	// Send invalid protobuf data
 	report := ocr3types.ReportWithInfo[[]byte]{Report: []byte("invalid protobuf")}
@@ -139,7 +140,7 @@ func TestTransmitter_Transmit_ArbiterError(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
 	mock := &mockArbiterScaler{err: context.DeadlineExceeded}
-	tx := NewTransmitter(lggr, store, mock, "test-account")
+	tx := NewTransmitter(lggr, store, nil, mock, "test-account")
 
 	outcome := &pb.Outcome{
 		State: &pb.RoutingState{
@@ -156,7 +157,7 @@ func TestTransmitter_Transmit_ArbiterError(t *testing.T) {
 func TestTransmitter_Transmit_NilState(t *testing.T) {
 	lggr := logger.Test(t)
 	store := NewStore()
-	tx := NewTransmitter(lggr, store, nil, "test-account")
+	tx := NewTransmitter(lggr, store, nil, nil, "test-account")
 
 	outcome := &pb.Outcome{
 		State:  nil,
diff --git a/pkg/workflows/shardorchestrator/pb/generate.go b/pkg/workflows/shardorchestrator/pb/generate.go
new file mode 100644
index 000000000..be4026238
--- /dev/null
+++ b/pkg/workflows/shardorchestrator/pb/generate.go
@@ -0,0 +1,3 @@
+package pb
+
+//go:generate protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative shard_orchestrator.proto
diff --git a/pkg/workflows/ring/pb/shard_orchestrator.pb.go b/pkg/workflows/shardorchestrator/pb/shard_orchestrator.pb.go
similarity index 77%
rename from pkg/workflows/ring/pb/shard_orchestrator.pb.go
rename to pkg/workflows/shardorchestrator/pb/shard_orchestrator.pb.go
index 7a3f8491e..eb3dccda1 100644
--- a/pkg/workflows/ring/pb/shard_orchestrator.pb.go
+++ b/pkg/workflows/shardorchestrator/pb/shard_orchestrator.pb.go
@@ -318,7 +318,7 @@ var File_shard_orchestrator_proto protoreflect.FileDescriptor
 
 const file_shard_orchestrator_proto_rawDesc = "" +
 	"\n" +
-	"\x18shard_orchestrator.proto\x12\x04ring\x1a\x1fgoogle/protobuf/timestamp.proto\"C\n" +
+	"\x18shard_orchestrator.proto\x12\x11shardorchestrator\x1a\x1fgoogle/protobuf/timestamp.proto\"C\n" +
 	"\x1eGetWorkflowShardMappingRequest\x12!\n" +
 	"\fworkflow_ids\x18\x01 \x03(\tR\vworkflowIds\"\xbe\x01\n" +
 	"\x14WorkflowMappingState\x12 \n" +
@@ -327,31 +327,31 @@ const file_shard_orchestrator_proto_rawDesc = "" +
 	"\fnew_shard_id\x18\x02 \x01(\rR\n" +
 	"newShardId\x12#\n" +
 	"\rin_transition\x18\x03 \x01(\bR\finTransition\x12=\n" +
-	"\flast_updated\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\vlastUpdated\"\xd1\x03\n" +
-	"\x1fGetWorkflowShardMappingResponse\x12O\n" +
-	"\bmappings\x18\x01 \x03(\v23.ring.GetWorkflowShardMappingResponse.MappingsEntryR\bmappings\x12_\n" +
-	"\x0emapping_states\x18\x02 \x03(\v28.ring.GetWorkflowShardMappingResponse.MappingStatesEntryR\rmappingStates\x128\n" +
+	"\flast_updated\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\vlastUpdated\"\xf8\x03\n" +
+	"\x1fGetWorkflowShardMappingResponse\x12\\\n" +
+	"\bmappings\x18\x01 \x03(\v2@.shardorchestrator.GetWorkflowShardMappingResponse.MappingsEntryR\bmappings\x12l\n" +
+	"\x0emapping_states\x18\x02 \x03(\v2E.shardorchestrator.GetWorkflowShardMappingResponse.MappingStatesEntryR\rmappingStates\x128\n" +
 	"\ttimestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12'\n" +
 	"\x0fmapping_version\x18\x04 \x01(\x04R\x0emappingVersion\x1a;\n" +
 	"\rMappingsEntry\x12\x10\n" +
 	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
-	"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\x1a\\\n" +
+	"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\x1ai\n" +
 	"\x12MappingStatesEntry\x12\x10\n" +
-	"\x03key\x18\x01 \x01(\tR\x03key\x120\n" +
-	"\x05value\x18\x02 \x01(\v2\x1a.ring.WorkflowMappingStateR\x05value:\x028\x01\"\x93\x03\n" +
+	"\x03key\x18\x01 \x01(\tR\x03key\x12=\n" +
+	"\x05value\x18\x02 \x01(\v2'.shardorchestrator.WorkflowMappingStateR\x05value:\x028\x01\"\xa1\x03\n" +
 	"(ReportWorkflowTriggerRegistrationRequest\x12&\n" +
-	"\x0fsource_shard_id\x18\x01 \x01(\rR\rsourceShardId\x12z\n" +
-	"\x14registered_workflows\x18\x02 \x03(\v2G.ring.ReportWorkflowTriggerRegistrationRequest.RegisteredWorkflowsEntryR\x13registeredWorkflows\x12E\n" +
+	"\x0fsource_shard_id\x18\x01 \x01(\rR\rsourceShardId\x12\x87\x01\n" +
+	"\x14registered_workflows\x18\x02 \x03(\v2T.shardorchestrator.ReportWorkflowTriggerRegistrationRequest.RegisteredWorkflowsEntryR\x13registeredWorkflows\x12E\n" +
 	"\x10report_timestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x0freportTimestamp\x124\n" +
 	"\x16total_active_workflows\x18\x04 \x01(\rR\x14totalActiveWorkflows\x1aF\n" +
 	"\x18RegisteredWorkflowsEntry\x12\x10\n" +
 	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
 	"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\"E\n" +
 	")ReportWorkflowTriggerRegistrationResponse\x12\x18\n" +
-	"\asuccess\x18\x01 \x01(\bR\asuccess2\x89\x02\n" +
-	"\x18ShardOrchestratorService\x12f\n" +
-	"\x17GetWorkflowShardMapping\x12$.ring.GetWorkflowShardMappingRequest\x1a%.ring.GetWorkflowShardMappingResponse\x12\x84\x01\n" +
-	"!ReportWorkflowTriggerRegistration\x12..ring.ReportWorkflowTriggerRegistrationRequest\x1a/.ring.ReportWorkflowTriggerRegistrationResponseBDZBgithub.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pbb\x06proto3"
+	"\asuccess\x18\x01 \x01(\bR\asuccess2\xbe\x02\n" +
+	"\x18ShardOrchestratorService\x12\x80\x01\n" +
+	"\x17GetWorkflowShardMapping\x121.shardorchestrator.GetWorkflowShardMappingRequest\x1a2.shardorchestrator.GetWorkflowShardMappingResponse\x12\x9e\x01\n" +
+	"!ReportWorkflowTriggerRegistration\x12;.shardorchestrator.ReportWorkflowTriggerRegistrationRequest\x1a<.shardorchestrator.ReportWorkflowTriggerRegistrationResponseBQZOgithub.com/smartcontractkit/chainlink-common/pkg/workflows/shardorchestrator/pbb\x06proto3"
 
 var (
 	file_shard_orchestrator_proto_rawDescOnce sync.Once
@@ -367,28 +367,28 @@ func file_shard_orchestrator_proto_rawDescGZIP() []byte {
 
 var file_shard_orchestrator_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
 var file_shard_orchestrator_proto_goTypes = []any{
-	(*GetWorkflowShardMappingRequest)(nil),            // 0: ring.GetWorkflowShardMappingRequest
-	(*WorkflowMappingState)(nil),                      // 1: ring.WorkflowMappingState
-	(*GetWorkflowShardMappingResponse)(nil),           // 2: ring.GetWorkflowShardMappingResponse
-	(*ReportWorkflowTriggerRegistrationRequest)(nil),  // 3: ring.ReportWorkflowTriggerRegistrationRequest
-	(*ReportWorkflowTriggerRegistrationResponse)(nil), // 4: ring.ReportWorkflowTriggerRegistrationResponse
-	nil,                           // 5: ring.GetWorkflowShardMappingResponse.MappingsEntry
-	nil,                           // 6: ring.GetWorkflowShardMappingResponse.MappingStatesEntry
-	nil,                           // 7: ring.ReportWorkflowTriggerRegistrationRequest.RegisteredWorkflowsEntry
+	(*GetWorkflowShardMappingRequest)(nil),            // 0: shardorchestrator.GetWorkflowShardMappingRequest
+	(*WorkflowMappingState)(nil),                      // 1: shardorchestrator.WorkflowMappingState
+	(*GetWorkflowShardMappingResponse)(nil),           // 2: shardorchestrator.GetWorkflowShardMappingResponse
+	(*ReportWorkflowTriggerRegistrationRequest)(nil),  // 3: shardorchestrator.ReportWorkflowTriggerRegistrationRequest
+	(*ReportWorkflowTriggerRegistrationResponse)(nil), // 4: shardorchestrator.ReportWorkflowTriggerRegistrationResponse
+	nil,                           // 5: shardorchestrator.GetWorkflowShardMappingResponse.MappingsEntry
+	nil,                           // 6: shardorchestrator.GetWorkflowShardMappingResponse.MappingStatesEntry
+	nil,                           // 7: shardorchestrator.ReportWorkflowTriggerRegistrationRequest.RegisteredWorkflowsEntry
 	(*timestamppb.Timestamp)(nil), // 8: google.protobuf.Timestamp
 }
 var file_shard_orchestrator_proto_depIdxs = []int32{
-	8, // 0: ring.WorkflowMappingState.last_updated:type_name -> google.protobuf.Timestamp
-	5, // 1: ring.GetWorkflowShardMappingResponse.mappings:type_name -> ring.GetWorkflowShardMappingResponse.MappingsEntry
-	6, // 2: ring.GetWorkflowShardMappingResponse.mapping_states:type_name -> ring.GetWorkflowShardMappingResponse.MappingStatesEntry
-	8, // 3: ring.GetWorkflowShardMappingResponse.timestamp:type_name -> google.protobuf.Timestamp
-	7, // 4: ring.ReportWorkflowTriggerRegistrationRequest.registered_workflows:type_name -> ring.ReportWorkflowTriggerRegistrationRequest.RegisteredWorkflowsEntry
-	8, // 5: ring.ReportWorkflowTriggerRegistrationRequest.report_timestamp:type_name -> google.protobuf.Timestamp
-	1, // 6: ring.GetWorkflowShardMappingResponse.MappingStatesEntry.value:type_name -> ring.WorkflowMappingState
-	0, // 7: ring.ShardOrchestratorService.GetWorkflowShardMapping:input_type -> ring.GetWorkflowShardMappingRequest
-	3, // 8: ring.ShardOrchestratorService.ReportWorkflowTriggerRegistration:input_type -> ring.ReportWorkflowTriggerRegistrationRequest
-	2, // 9: ring.ShardOrchestratorService.GetWorkflowShardMapping:output_type -> ring.GetWorkflowShardMappingResponse
-	4, // 10: ring.ShardOrchestratorService.ReportWorkflowTriggerRegistration:output_type -> ring.ReportWorkflowTriggerRegistrationResponse
+	8, // 0: shardorchestrator.WorkflowMappingState.last_updated:type_name -> google.protobuf.Timestamp
+	5, // 1: shardorchestrator.GetWorkflowShardMappingResponse.mappings:type_name -> shardorchestrator.GetWorkflowShardMappingResponse.MappingsEntry
+	6, // 2: shardorchestrator.GetWorkflowShardMappingResponse.mapping_states:type_name -> shardorchestrator.GetWorkflowShardMappingResponse.MappingStatesEntry
+	8, // 3: shardorchestrator.GetWorkflowShardMappingResponse.timestamp:type_name -> google.protobuf.Timestamp
+	7, // 4: shardorchestrator.ReportWorkflowTriggerRegistrationRequest.registered_workflows:type_name -> shardorchestrator.ReportWorkflowTriggerRegistrationRequest.RegisteredWorkflowsEntry
+	8, // 5: shardorchestrator.ReportWorkflowTriggerRegistrationRequest.report_timestamp:type_name -> google.protobuf.Timestamp
+	1, // 6: shardorchestrator.GetWorkflowShardMappingResponse.MappingStatesEntry.value:type_name -> shardorchestrator.WorkflowMappingState
+	0, // 7: shardorchestrator.ShardOrchestratorService.GetWorkflowShardMapping:input_type -> shardorchestrator.GetWorkflowShardMappingRequest
+	3, // 8: shardorchestrator.ShardOrchestratorService.ReportWorkflowTriggerRegistration:input_type -> shardorchestrator.ReportWorkflowTriggerRegistrationRequest
+	2, // 9: shardorchestrator.ShardOrchestratorService.GetWorkflowShardMapping:output_type -> shardorchestrator.GetWorkflowShardMappingResponse
+	4, // 10: shardorchestrator.ShardOrchestratorService.ReportWorkflowTriggerRegistration:output_type -> shardorchestrator.ReportWorkflowTriggerRegistrationResponse
 	9, // [9:11] is the sub-list for method output_type
 	7, // [7:9] is the sub-list for method input_type
 	7, // [7:7] is the sub-list for extension type_name
diff --git a/pkg/workflows/ring/pb/shard_orchestrator.proto b/pkg/workflows/shardorchestrator/pb/shard_orchestrator.proto
similarity index 95%
rename from pkg/workflows/ring/pb/shard_orchestrator.proto
rename to pkg/workflows/shardorchestrator/pb/shard_orchestrator.proto
index c7e3c1668..51930f13c 100644
--- a/pkg/workflows/ring/pb/shard_orchestrator.proto
+++ b/pkg/workflows/shardorchestrator/pb/shard_orchestrator.proto
@@ -1,10 +1,10 @@
 syntax = "proto3";
 
-package ring;
+package shardorchestrator;
 
 import "google/protobuf/timestamp.proto";
 
-option go_package = "github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb";
+option go_package = "github.com/smartcontractkit/chainlink-common/pkg/workflows/shardorchestrator/pb";
 
 message GetWorkflowShardMappingRequest {
   repeated string workflow_ids = 1;
diff --git a/pkg/workflows/ring/pb/shard_orchestrator_grpc.pb.go b/pkg/workflows/shardorchestrator/pb/shard_orchestrator_grpc.pb.go
similarity index 96%
rename from pkg/workflows/ring/pb/shard_orchestrator_grpc.pb.go
rename to pkg/workflows/shardorchestrator/pb/shard_orchestrator_grpc.pb.go
index d2ab234c3..d099fd0ac 100644
--- a/pkg/workflows/ring/pb/shard_orchestrator_grpc.pb.go
+++ b/pkg/workflows/shardorchestrator/pb/shard_orchestrator_grpc.pb.go
@@ -19,8 +19,8 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	ShardOrchestratorService_GetWorkflowShardMapping_FullMethodName           = "/ring.ShardOrchestratorService/GetWorkflowShardMapping"
-	ShardOrchestratorService_ReportWorkflowTriggerRegistration_FullMethodName = "/ring.ShardOrchestratorService/ReportWorkflowTriggerRegistration"
+	ShardOrchestratorService_GetWorkflowShardMapping_FullMethodName           = "/shardorchestrator.ShardOrchestratorService/GetWorkflowShardMapping"
+	ShardOrchestratorService_ReportWorkflowTriggerRegistration_FullMethodName = "/shardorchestrator.ShardOrchestratorService/ReportWorkflowTriggerRegistration"
 )
 
 // ShardOrchestratorServiceClient is the client API for ShardOrchestratorService service.
@@ -143,7 +143,7 @@ func _ShardOrchestratorService_ReportWorkflowTriggerRegistration_Handler(srv int
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
 var ShardOrchestratorService_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "ring.ShardOrchestratorService",
+	ServiceName: "shardorchestrator.ShardOrchestratorService",
 	HandlerType: (*ShardOrchestratorServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
diff --git a/pkg/workflows/shardorchestrator/service.go b/pkg/workflows/shardorchestrator/service.go
new file mode 100644
index 000000000..d3fd8e811
--- /dev/null
+++ b/pkg/workflows/shardorchestrator/service.go
@@ -0,0 +1,112 @@
+package shardorchestrator
+
+import (
+	"context"
+	"fmt"
+
+	"google.golang.org/grpc"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/shardorchestrator/pb"
+)
+
+// Server implements the gRPC ShardOrchestratorService
+// This runs on shard zero and serves requests from other shards
+type Server struct {
+	pb.UnimplementedShardOrchestratorServiceServer
+	store  *Store
+	logger logger.Logger
+}
+
+func NewServer(store *Store, lggr logger.Logger) *Server {
+	return &Server{
+		store:  store,
+		logger: logger.Named(lggr, "ShardOrchestratorServer"),
+	}
+}
+
+// RegisterWithGRPCServer registers this service with a gRPC server
+func (s *Server) RegisterWithGRPCServer(grpcServer *grpc.Server) {
+	pb.RegisterShardOrchestratorServiceServer(grpcServer, s)
+	s.logger.Info("Registered ShardOrchestrator gRPC service")
+}
+
+// GetWorkflowShardMapping handles batch requests for workflow-to-shard mappings
+// This is called by other shards to determine where to route workflow executions
+func (s *Server) GetWorkflowShardMapping(ctx context.Context, req *pb.GetWorkflowShardMappingRequest) (*pb.GetWorkflowShardMappingResponse, error) {
+	s.logger.Debugw("GetWorkflowShardMapping called", "workflowCount", len(req.WorkflowIds))
+
+	if len(req.WorkflowIds) == 0 {
+		return nil, fmt.Errorf("workflow_ids is required and must not be empty")
+	}
+
+	// Retrieve batch from store
+	mappings, version, timestamp, err := s.store.GetWorkflowMappingsBatch(ctx, req.WorkflowIds)
+	if err != nil {
+		s.logger.Errorw("Failed to get workflow mappings", "error", err)
+		return nil, fmt.Errorf("failed to get workflow mappings: %w", err)
+	}
+
+	// Build simple mappings map (workflow_id -> shard_id)
+	simpleMappings := make(map[string]uint32, len(mappings))
+	// Build detailed mapping states
+	mappingStates := make(map[string]*pb.WorkflowMappingState, len(mappings))
+
+	for workflowID, mapping := range mappings {
+		// Simple mapping: just the current shard
+		simpleMappings[workflowID] = mapping.NewShardID
+
+		// Detailed state: includes transition information
+		inTransition := mapping.TransitionState == "transitioning"
+		mappingStates[workflowID] = &pb.WorkflowMappingState{
+			OldShardId:   mapping.OldShardID,
+			NewShardId:   mapping.NewShardID,
+			InTransition: inTransition,
+			LastUpdated:  timestamppb.New(mapping.UpdatedAt),
+		}
+	}
+
+	return &pb.GetWorkflowShardMappingResponse{
+		Mappings:       simpleMappings,
+		MappingStates:  mappingStates,
+		Timestamp:      timestamppb.New(timestamp),
+		MappingVersion: version,
+	}, nil
+}
+
+// ReportWorkflowTriggerRegistration handles shard registration reports
+// Shards call this to inform shard zero about which workflows they have loaded
+func (s *Server) ReportWorkflowTriggerRegistration(ctx context.Context, req *pb.ReportWorkflowTriggerRegistrationRequest) (*pb.ReportWorkflowTriggerRegistrationResponse, error) {
+	s.logger.Debugw("ReportWorkflowTriggerRegistration called",
+		"shardID", req.SourceShardId,
+		"workflowCount", len(req.RegisteredWorkflows),
+		"totalActive", req.TotalActiveWorkflows,
+	)
+
+	// Extract workflow IDs from the map
+	workflowIDs := make([]string, 0, len(req.RegisteredWorkflows))
+	for workflowID := range req.RegisteredWorkflows {
+		workflowIDs = append(workflowIDs, workflowID)
+	}
+
+	err := s.store.ReportShardRegistration(ctx, req.SourceShardId, workflowIDs)
+	if err != nil {
+		s.logger.Errorw("Failed to update shard registrations",
+			"shardID", req.SourceShardId,
+			"error", err,
+		)
+		return &pb.ReportWorkflowTriggerRegistrationResponse{
+			Success: false,
+		}, nil
+	}
+
+	s.logger.Infow("Successfully registered workflows",
+		"shardID", req.SourceShardId,
+		"workflowCount", len(workflowIDs),
+	)
+
+	return &pb.ReportWorkflowTriggerRegistrationResponse{
+		Success: true,
+	}, nil
+}
diff --git a/pkg/workflows/shardorchestrator/store.go b/pkg/workflows/shardorchestrator/store.go
new file mode 100644
index 000000000..00b5dae3a
--- /dev/null
+++ b/pkg/workflows/shardorchestrator/store.go
@@ -0,0 +1,215 @@
+package shardorchestrator
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+)
+
+// WorkflowMappingState represents the state of a workflow assignment
+type WorkflowMappingState struct {
+	WorkflowID      string
+	OldShardID      uint32
+	NewShardID      uint32
+	TransitionState string // "steady", "transitioning"
+	UpdatedAt       time.Time
+}
+
+// Store manages workflow-to-shard mappings that will be exposed via gRPC
+// RingOCR plugin updates this store, and the gRPC service reads from it
+type Store struct {
+	// workflowMappings tracks the current shard assignment for each workflow
+	workflowMappings map[string]*WorkflowMappingState // workflow_id -> mapping state
+
+	// shardRegistrations tracks what workflows each shard has registered
+	// This is populated by ReportWorkflowTriggerRegistration calls from shards
+	shardRegistrations map[uint32]map[string]bool // shard_id -> set of workflow_ids
+
+	// mappingVersion increments on any change to workflowMappings
+	// Used by clients for cache invalidation
+	mappingVersion uint64
+
+	// lastUpdateTime tracks when mappings were last modified
+	lastUpdateTime time.Time
+
+	mu     sync.RWMutex
+	logger logger.Logger
+}
+
+func NewStore(lggr logger.Logger) *Store {
+	return &Store{
+		workflowMappings:   make(map[string]*WorkflowMappingState),
+		shardRegistrations: make(map[uint32]map[string]bool),
+		mappingVersion:     0,
+		lastUpdateTime:     time.Now(),
+		logger:             logger.Named(lggr, "ShardOrchestratorStore"),
+	}
+}
+
+// UpdateWorkflowMapping is called by RingOCR to update workflow assignments
+// This is the primary data source for shard orchestration
+func (s *Store) UpdateWorkflowMapping(ctx context.Context, workflowID string, oldShardID, newShardID uint32, state string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	now := time.Now()
+	s.workflowMappings[workflowID] = &WorkflowMappingState{
+		WorkflowID:      workflowID,
+		OldShardID:      oldShardID,
+		NewShardID:      newShardID,
+		TransitionState: state,
+		UpdatedAt:       now,
+	}
+
+	s.mappingVersion++
+	s.lastUpdateTime = now
+
+	s.logger.Debugw("Updated workflow mapping",
+		"workflowID", workflowID,
+		"oldShardID", oldShardID,
+		"newShardID", newShardID,
+		"state", state,
+		"version", s.mappingVersion,
+	)
+
+	return nil
+}
+
+// BatchUpdateWorkflowMappings allows RingOCR to update multiple mappings atomically
+func (s *Store) BatchUpdateWorkflowMappings(ctx context.Context, mappings []*WorkflowMappingState) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	now := time.Now()
+	for _, mapping := range mappings {
+		s.workflowMappings[mapping.WorkflowID] = &WorkflowMappingState{
+			WorkflowID:      mapping.WorkflowID,
+			OldShardID:      mapping.OldShardID,
+			NewShardID:      mapping.NewShardID,
+			TransitionState: mapping.TransitionState,
+			UpdatedAt:       now,
+		}
+	}
+
+	s.mappingVersion++
+	s.lastUpdateTime = now
+
+	s.logger.Debugw("Batch updated workflow mappings", "count", len(mappings), "version", s.mappingVersion)
+	return nil
+}
+
+// GetWorkflowMapping retrieves the shard assignment for a specific workflow
+// This is called by the gRPC service to respond to GetWorkflowShardMapping requests
+func (s *Store) GetWorkflowMapping(ctx context.Context, workflowID string) (*WorkflowMappingState, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	mapping, ok := s.workflowMappings[workflowID]
+	if !ok {
+		return nil, fmt.Errorf("workflow %s not found in shard mappings", workflowID)
+	}
+
+	// Return a copy to avoid external mutations
+	return &WorkflowMappingState{
+		WorkflowID:      mapping.WorkflowID,
+		OldShardID:      mapping.OldShardID,
+		NewShardID:      mapping.NewShardID,
+		TransitionState: mapping.TransitionState,
+		UpdatedAt:       mapping.UpdatedAt,
+	}, nil
+}
+
+// GetAllWorkflowMappings returns all current workflow-to-shard assignments
+func (s *Store) GetAllWorkflowMappings(ctx context.Context) ([]*WorkflowMappingState, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	mappings := make([]*WorkflowMappingState, 0, len(s.workflowMappings))
+	for _, mapping := range s.workflowMappings {
+		mappings = append(mappings, &WorkflowMappingState{
+			WorkflowID:      mapping.WorkflowID,
+			OldShardID:      mapping.OldShardID,
+			NewShardID:      mapping.NewShardID,
+			TransitionState: mapping.TransitionState,
+			UpdatedAt:       mapping.UpdatedAt,
+		})
+	}
+
+	return mappings, nil
+}
+
+// ReportShardRegistration is called when a shard reports its registered workflows
+// This helps track which workflows each shard has successfully loaded
+func (s *Store) ReportShardRegistration(ctx context.Context, shardID uint32, workflowIDs []string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// Initialize the set for this shard if needed
+	if s.shardRegistrations[shardID] == nil {
+		s.shardRegistrations[shardID] = make(map[string]bool)
+	}
+
+	// Clear and update
+	s.shardRegistrations[shardID] = make(map[string]bool)
+	for _, wfID := range workflowIDs {
+		s.shardRegistrations[shardID][wfID] = true
+	}
+
+	s.logger.Debugw("Updated shard registrations",
+		"shardID", shardID,
+		"workflowCount", len(workflowIDs),
+	)
+
+	return nil
+}
+
+// GetShardRegistrations returns the workflows registered on a specific shard
+func (s *Store) GetShardRegistrations(ctx context.Context, shardID uint32) ([]string, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	workflows, ok := s.shardRegistrations[shardID]
+	if !ok {
+		return []string{}, nil
+	}
+
+	result := make([]string, 0, len(workflows))
+	for wfID := range workflows {
+		result = append(result, wfID)
+	}
+
+	return result, nil
+}
+
+// GetWorkflowMappingsBatch retrieves mappings for multiple workflows
+func (s *Store) GetWorkflowMappingsBatch(ctx context.Context, workflowIDs []string) (map[string]*WorkflowMappingState, uint64, time.Time, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	result := make(map[string]*WorkflowMappingState, len(workflowIDs))
+
+	for _, workflowID := range workflowIDs {
+		if mapping, ok := s.workflowMappings[workflowID]; ok {
+			// Return a copy to avoid external mutations
+			result[workflowID] = &WorkflowMappingState{
+				WorkflowID:      mapping.WorkflowID,
+				OldShardID:      mapping.OldShardID,
+				NewShardID:      mapping.NewShardID,
+				TransitionState: mapping.TransitionState,
+				UpdatedAt:       mapping.UpdatedAt,
+			}
+		}
+	}
+
+	return result, s.mappingVersion, s.lastUpdateTime, nil
+}
+
+// GetMappingVersion returns the current version of the mapping set
+func (s *Store) GetMappingVersion() uint64 {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.mappingVersion
+}
diff --git a/pkg/workflows/shardorchestrator/store_test.go b/pkg/workflows/shardorchestrator/store_test.go
new file mode 100644
index 000000000..bef19ea59
--- /dev/null
+++ b/pkg/workflows/shardorchestrator/store_test.go
@@ -0,0 +1,199 @@
+package shardorchestrator_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/shardorchestrator"
+)
+
+func TestStore_BatchUpdateAndQuery(t *testing.T) {
+	ctx := context.Background()
+	lggr := logger.Test(t)
+	store := shardorchestrator.NewStore(lggr)
+
+	// Create and insert multiple workflow mappings
+	mappings := []*shardorchestrator.WorkflowMappingState{
+		{
+			WorkflowID:      "workflow-1",
+			OldShardID:      0,
+			NewShardID:      1,
+			TransitionState: "steady",
+		},
+		{
+			WorkflowID:      "workflow-2",
+			OldShardID:      0,
+			NewShardID:      2,
+			TransitionState: "steady",
+		},
+		{
+			WorkflowID:      "workflow-3",
+			OldShardID:      0,
+			NewShardID:      1,
+			TransitionState: "steady",
+		},
+	}
+
+	err := store.BatchUpdateWorkflowMappings(ctx, mappings)
+	require.NoError(t, err)
+
+	// Query individual workflow
+	mapping1, err := store.GetWorkflowMapping(ctx, "workflow-1")
+	require.NoError(t, err)
+	assert.Equal(t, uint32(1), mapping1.NewShardID)
+	assert.Equal(t, "steady", mapping1.TransitionState)
+
+	// Query all workflows
+	allMappings, err := store.GetAllWorkflowMappings(ctx)
+	require.NoError(t, err)
+	assert.Len(t, allMappings, 3)
+
+	// Query batch
+	batchMappings, version, timestamp, err := store.GetWorkflowMappingsBatch(ctx, []string{"workflow-1", "workflow-2"})
+	require.NoError(t, err)
+	assert.Len(t, batchMappings, 2)
+	assert.Equal(t, uint64(1), version) // First update
+	assert.False(t, timestamp.IsZero())
+}
+
+func TestStore_WorkflowTransition(t *testing.T) {
+	ctx := context.Background()
+	lggr := logger.Test(t)
+	store := shardorchestrator.NewStore(lggr)
+
+	// Initial assignment
+	err := store.UpdateWorkflowMapping(ctx, "workflow-123", 0, 1, "steady")
+	require.NoError(t, err)
+
+	mapping, err := store.GetWorkflowMapping(ctx, "workflow-123")
+	require.NoError(t, err)
+	assert.Equal(t, uint32(1), mapping.NewShardID)
+	assert.Equal(t, "steady", mapping.TransitionState)
+
+	// Move to different shard (transitioning)
+	err = store.UpdateWorkflowMapping(ctx, "workflow-123", 1, 3, "transitioning")
+	require.NoError(t, err)
+
+	mapping, err = store.GetWorkflowMapping(ctx, "workflow-123")
+	require.NoError(t, err)
+	assert.Equal(t, uint32(1), mapping.OldShardID)
+	assert.Equal(t, uint32(3), mapping.NewShardID)
+	assert.Equal(t, "transitioning", mapping.TransitionState)
+
+	// Complete transition
+	err = store.UpdateWorkflowMapping(ctx, "workflow-123", 1, 3, "steady")
+	require.NoError(t, err)
+
+	mapping, err = store.GetWorkflowMapping(ctx, "workflow-123")
+	require.NoError(t, err)
+	assert.Equal(t, uint32(3), mapping.NewShardID)
+	assert.Equal(t, "steady", mapping.TransitionState)
+}
+
+func TestStore_VersionTracking(t *testing.T) {
+	ctx := context.Background()
+	lggr := logger.Test(t)
+	store := shardorchestrator.NewStore(lggr)
+
+	// Initial version should be 0
+	assert.Equal(t, uint64(0), store.GetMappingVersion())
+
+	// First update increments version
+	err := store.UpdateWorkflowMapping(ctx, "wf-1", 0, 1, "steady")
+	require.NoError(t, err)
+	assert.Equal(t, uint64(1), store.GetMappingVersion())
+
+	// Batch update increments version
+	err = store.BatchUpdateWorkflowMappings(ctx, []*shardorchestrator.WorkflowMappingState{
+		{WorkflowID: "wf-2", NewShardID: 2, TransitionState: "steady"},
+	})
+	require.NoError(t, err)
+	assert.Equal(t, uint64(2), store.GetMappingVersion())
+
+	// Version is included in batch query response
+	_, version, _, err := store.GetWorkflowMappingsBatch(ctx, []string{"wf-1", "wf-2"})
+	require.NoError(t, err)
+	assert.Equal(t, uint64(2), version)
+}
+
+func TestStore_ShardRegistrations(t *testing.T) {
+	ctx := context.Background()
+	lggr := logger.Test(t)
+	store := shardorchestrator.NewStore(lggr)
+
+	// Shard 1 reports its workflows
+	err := store.ReportShardRegistration(ctx, 1, []string{"workflow-1", "workflow-3"})
+	require.NoError(t, err)
+
+	// Shard 2 reports its workflows
+	err = store.ReportShardRegistration(ctx, 2, []string{"workflow-2"})
+	require.NoError(t, err)
+
+	// Query shard registrations
+	shard1Workflows, err := store.GetShardRegistrations(ctx, 1)
+	require.NoError(t, err)
+	assert.Len(t, shard1Workflows, 2)
+	assert.Contains(t, shard1Workflows, "workflow-1")
+	assert.Contains(t, shard1Workflows, "workflow-3")
+
+	shard2Workflows, err := store.GetShardRegistrations(ctx, 2)
+	require.NoError(t, err)
+	assert.Len(t, shard2Workflows, 1)
+	assert.Contains(t, shard2Workflows, "workflow-2")
+
+	// Query non-existent shard returns empty
+	shard3Workflows, err := store.GetShardRegistrations(ctx, 3)
+	require.NoError(t, err)
+	assert.Empty(t, shard3Workflows)
+
+	// Re-reporting replaces previous registrations
+	err = store.ReportShardRegistration(ctx, 1, []string{"workflow-1"})
+	require.NoError(t, err)
+
+	shard1Workflows, err = store.GetShardRegistrations(ctx, 1)
+	require.NoError(t, err)
+	assert.Len(t, shard1Workflows, 1)
+	assert.Contains(t, shard1Workflows, "workflow-1")
+	assert.NotContains(t, shard1Workflows, "workflow-3") // Removed
+}
+
+func TestStore_NotFoundError(t *testing.T) {
+	ctx := context.Background()
+	lggr := logger.Test(t)
+	store := shardorchestrator.NewStore(lggr)
+
+	// Query non-existent workflow
+	_, err := store.GetWorkflowMapping(ctx, "non-existent")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "not found")
+}
+
+func TestStore_BatchQueryPartialResults(t *testing.T) {
+	ctx := context.Background()
+	lggr := logger.Test(t)
+	store := shardorchestrator.NewStore(lggr)
+
+	// Insert only some workflows
+	err := store.UpdateWorkflowMapping(ctx, "exists-1", 0, 1, "steady")
+	require.NoError(t, err)
+	err = store.UpdateWorkflowMapping(ctx, "exists-2", 0, 2, "steady")
+	require.NoError(t, err)
+
+	// Query mix of existing and non-existing workflows
+	results, _, _, err := store.GetWorkflowMappingsBatch(ctx, []string{
+		"exists-1",
+		"non-existent",
+		"exists-2",
+	})
+	require.NoError(t, err)
+
+	// Should only return existing ones
+	assert.Len(t, results, 2)
+	assert.Contains(t, results, "exists-1")
+	assert.Contains(t, results, "exists-2")
+	assert.NotContains(t, results, "non-existent")
+}