--- a/proxy/tun/udp_fullcone.go
+++ b/proxy/tun/udp_fullcone.go
@@ -11,6 +11,22 @@
 	"github.com/xtls/xray-core/common/net"
 )
 
+// DNS and QUIC use fixed-destination VLESS UDP streams. A shared source
+// socket must not alias another remote endpoint onto its first destination.
+// Other UDP retains the existing source-only FullCone association behavior.
+type udpAssociationKey struct {
+	source      net.Destination
+	destination net.Destination
+}
+
+func associationKey(source, destination net.Destination) udpAssociationKey {
+	key := udpAssociationKey{source: source}
+	if destination.Port == 53 || destination.Port == 443 {
+		key.destination = destination
+	}
+	return key
+}
+
 type packet struct {
 	data []byte
 	dest *net.Destination
@@ -20,7 +36,7 @@
 type udpConnectionHandler struct {
 	sync.RWMutex
 
-	udpConns map[net.Destination]*udpConn
+	udpConns map[udpAssociationKey]*udpConn
 
 	handleConnection func(conn net.Conn, dest net.Destination)
 	writePacket      func(data []byte, src net.Destination, dst net.Destination) error
@@ -28,7 +44,7 @@
 
 func newUdpConnectionHandler(handleConnection func(conn net.Conn, dest net.Destination), writePacket func(data []byte, src net.Destination, dst net.Destination) error) *udpConnectionHandler {
 	handler := &udpConnectionHandler{
-		udpConns:         make(map[net.Destination]*udpConn),
+		udpConns:         make(map[udpAssociationKey]*udpConn),
 		handleConnection: handleConnection,
 		writePacket:      writePacket,
 	}
@@ -39,8 +55,9 @@
 // HandlePacket handles UDP packets coming from tun, to forward to the dispatcher
 // this custom handler support FullCone NAT of returning packets, binding connection only by the source addr:port
 func (u *udpConnectionHandler) HandlePacket(src net.Destination, dst net.Destination, data []byte) {
+	key := associationKey(src, dst)
 	u.RLock()
-	conn, found := u.udpConns[src]
+	conn, found := u.udpConns[key]
 	if found {
 		select {
 		case conn.egress <- &packet{
@@ -58,11 +75,11 @@
 	u.Lock()
 	defer u.Unlock()
 
-	conn, found = u.udpConns[src]
+	conn, found = u.udpConns[key]
 	if !found {
 		egress := make(chan *packet, 1024)
-		conn = &udpConn{handler: u, egress: egress, src: src, dst: dst}
-		u.udpConns[src] = conn
+		conn = &udpConn{handler: u, egress: egress, src: src, dst: dst, key: key}
+		u.udpConns[key] = conn
 
 		go u.handleConnection(conn, dst)
 	}
@@ -81,8 +98,8 @@
 func (u *udpConnectionHandler) connectionFinished(conn *udpConn) {
 	u.Lock()
 	// Close runs twice per flow; a newer conn may already own this src.
-	if u.udpConns[conn.src] == conn {
-		delete(u.udpConns, conn.src)
+	if u.udpConns[conn.key] == conn {
+		delete(u.udpConns, conn.key)
 		close(conn.egress)
 	}
 	u.Unlock()
@@ -91,6 +108,7 @@
 // udp connection abstraction
 type udpConn struct {
 	handler *udpConnectionHandler
+	key     udpAssociationKey
 
 	egress chan *packet
 	src    net.Destination
--- a/proxy/tun/stack_gvisor_endpoint.go
+++ b/proxy/tun/stack_gvisor_endpoint.go
@@ -3,6 +3,9 @@
 import (
 	"context"
 	"errors"
+	"io"
+	"sync"
+	"syscall"
 
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
@@ -24,6 +27,9 @@
 	deviceMTU        uint32
 	device           GVisorDevice
 	dispatcherCancel context.CancelFunc
+	lifecycleMu      sync.Mutex
+	readerGeneration uint64
+	readerState      ReaderState
 }
 
 func (e *LinkEndpoint) MTU() uint32 {
@@ -50,21 +56,65 @@
 	return stack.CapabilityRXChecksumOffload
 }
 
+// ReaderState reports only local reader lifecycle, not end-to-end connectivity.
+// No packet, address, raw error string, or application traffic is exposed.
+type ReaderState struct {
+	State     string `json:"state"`
+	ErrorKind string `json:"errorKind,omitempty"`
+	ErrorCode int    `json:"errorCode,omitempty"`
+}
+
+func (e *LinkEndpoint) ReaderState() ReaderState {
+	e.lifecycleMu.Lock()
+	defer e.lifecycleMu.Unlock()
+	if e.readerState.State == "" {
+		return ReaderState{State: "unavailable"}
+	}
+	return e.readerState
+}
+
 func (e *LinkEndpoint) Attach(dispatcher stack.NetworkDispatcher) {
+	e.lifecycleMu.Lock()
+	defer e.lifecycleMu.Unlock()
 	if e.dispatcherCancel != nil {
 		e.dispatcherCancel()
-		e.dispatcherCancel = nil
-	}
-
+	}
+	e.dispatcherCancel = nil
+	e.readerGeneration++
+	e.readerState = ReaderState{State: "stopped"}
 	if dispatcher != nil {
 		ctx, cancel := context.WithCancel(context.Background())
-		go e.dispatchLoop(ctx, dispatcher)
 		e.dispatcherCancel = cancel
+		e.readerState = ReaderState{State: "running"}
+		go e.dispatchLoop(ctx, dispatcher, e.readerGeneration)
 	}
 }
 
 func (e *LinkEndpoint) IsAttached() bool {
+	e.lifecycleMu.Lock()
+	defer e.lifecycleMu.Unlock()
 	return e.dispatcherCancel != nil
+}
+
+func (e *LinkEndpoint) readerFailed(generation uint64, err error) {
+	e.lifecycleMu.Lock()
+	defer e.lifecycleMu.Unlock()
+	// An intentionally stopped or superseded reader cannot overwrite a newer
+	// attach/close or request repair of its replacement.
+	if generation != e.readerGeneration || e.dispatcherCancel == nil {
+		return
+	}
+	failure := ReaderState{State: "failed", ErrorKind: "other"}
+	var errno syscall.Errno
+	if errors.Is(err, io.EOF) {
+		failure.ErrorKind = "eof"
+	} else if errors.As(err, &errno) && errno > 0 && errno < 4096 {
+		failure.ErrorKind = "errno"
+		failure.ErrorCode = int(errno)
+	}
+	e.readerState = failure
+	e.dispatcherCancel()
+	e.dispatcherCancel = nil
 }
 
 func (e *LinkEndpoint) Wait() {
@@ -82,12 +132,7 @@
 	return true
 }
 
-func (e *LinkEndpoint) Close() {
-	if e.dispatcherCancel != nil {
-		e.dispatcherCancel()
-		e.dispatcherCancel = nil
-	}
-}
+func (e *LinkEndpoint) Close() { e.Attach(nil) }
 
 func (e *LinkEndpoint) SetOnCloseAction(_ func()) {
 }
@@ -107,7 +152,7 @@
 	return n, nil
 }
 
-func (e *LinkEndpoint) dispatchLoop(ctx context.Context, dispatcher stack.NetworkDispatcher) {
+func (e *LinkEndpoint) dispatchLoop(ctx context.Context, dispatcher stack.NetworkDispatcher, generation uint64) {
 	var networkProtocolNumber tcpip.NetworkProtocolNumber
 	var version byte
 	var packet *stack.PacketBuffer
@@ -126,7 +171,9 @@
 			}
 			// stop dispatcher loop on any other interface failure
 			if err != nil {
-				e.Attach(nil)
+				if ctx.Err() == nil {
+					e.readerFailed(generation, err)
+				}
 				return
 			}
 
--- a/proxy/tun/stack_gvisor.go
+++ b/proxy/tun/stack_gvisor.go
@@ -265,3 +265,11 @@
 
 	return gStack, nil
 }
+
+// TUNReaderState does not send traffic and does not claim forwarding success.
+func (t *stackGVisor) TUNReaderState() ReaderState {
+	if endpoint, ok := t.endpoint.(*LinkEndpoint); ok {
+		return endpoint.ReaderState()
+	}
+	return ReaderState{State: "unavailable"}
+}
--- a/proxy/tun/handler.go
+++ b/proxy/tun/handler.go
@@ -280,3 +280,11 @@
 		return t, err
 	}))
 }
+
+// TUNReaderState is a read-only health signal for managed native consumers.
+func (t *Handler) TUNReaderState() ReaderState {
+	if reader, ok := t.stack.(interface{ TUNReaderState() ReaderState }); ok {
+		return reader.TUNReaderState()
+	}
+	return ReaderState{State: "unavailable"}
+}
--- /dev/null
+++ b/proxy/tun/tivra_reader_state_test.go
@@ -0,0 +1,132 @@
+package tun
+
+import (
+	"errors"
+	"io"
+	"os"
+	"sync"
+	"sync/atomic"
+	"syscall"
+	"testing"
+	"time"
+
+	"gvisor.dev/gvisor/pkg/buffer"
+	"gvisor.dev/gvisor/pkg/tcpip"
+	"gvisor.dev/gvisor/pkg/tcpip/stack"
+)
+
+type readerTestEvent struct {
+	err    error
+	packet bool
+}
+type readerTestDevice struct {
+	events chan readerTestEvent
+	reads  atomic.Int32
+}
+
+func (d *readerTestDevice) WritePacket(*stack.PacketBuffer) tcpip.Error { return nil }
+func (d *readerTestDevice) ReadPacket() (byte, *stack.PacketBuffer, error) {
+	select {
+	case event := <-d.events:
+		d.reads.Add(1)
+		if event.err != nil {
+			return 0, nil, event.err
+		}
+		return 4, stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buffer.MakeWithData([]byte{0x45})}), nil
+	default:
+		return 0, nil, ErrQueueEmpty
+	}
+}
+func (*readerTestDevice) Wait() { time.Sleep(time.Millisecond) }
+
+type readerTestDispatcher struct{ delivered atomic.Int32 }
+
+func (d *readerTestDispatcher) DeliverNetworkPacket(tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {
+	d.delivered.Add(1)
+}
+func (*readerTestDispatcher) DeliverLinkPacket(tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {}
+func waitReaderTest(t *testing.T, condition func() bool) {
+	t.Helper()
+	deadline := time.Now().Add(time.Second)
+	for !condition() {
+		if time.Now().After(deadline) {
+			t.Fatal("timed out")
+		}
+		time.Sleep(time.Millisecond)
+	}
+}
+func TestTivraReaderFailureReportedWithoutBlindRetry(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		err  error
+		kind string
+		code int
+	}{
+		{"errno", &os.PathError{Op: "read", Path: "private-descriptor", Err: syscall.EIO}, "errno", int(syscall.EIO)},
+		{"eof", io.EOF, "eof", 0}, {"unknown", errors.New("sensitive underlying error"), "other", 0},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			device := &readerTestDevice{events: make(chan readerTestEvent, 4)}
+			dispatcher := &readerTestDispatcher{}
+			endpoint := &LinkEndpoint{device: device}
+			defer endpoint.Close()
+			endpoint.Attach(dispatcher)
+			device.events <- readerTestEvent{err: test.err}
+			device.events <- readerTestEvent{packet: true}
+			waitReaderTest(t, func() bool { return endpoint.ReaderState().State == "failed" })
+			got := endpoint.ReaderState()
+			if got.ErrorKind != test.kind || got.ErrorCode != test.code || endpoint.IsAttached() || device.reads.Load() != 1 {
+				t.Fatalf("incorrect failure snapshot %+v reads=%d", got, device.reads.Load())
+			}
+			endpoint.Attach(dispatcher)
+			waitReaderTest(t, func() bool { return dispatcher.delivered.Load() == 1 })
+			if endpoint.ReaderState().State != "running" {
+				t.Fatal("new reader inherited failure")
+			}
+			endpoint.Close()
+			if endpoint.ReaderState().State != "stopped" {
+				t.Fatal("intentional close marked failure")
+			}
+		})
+	}
+}
+func TestTivraReaderLateFailureCannotOverwriteReplacementOrStop(t *testing.T) {
+	device := &readerTestDevice{events: make(chan readerTestEvent, 4)}
+	endpoint := &LinkEndpoint{device: device}
+	defer endpoint.Close()
+	endpoint.Attach(&readerTestDispatcher{})
+	endpoint.lifecycleMu.Lock()
+	old := endpoint.readerGeneration
+	endpoint.lifecycleMu.Unlock()
+	endpoint.Attach(&readerTestDispatcher{})
+	endpoint.readerFailed(old, syscall.EIO)
+	if endpoint.ReaderState().State != "running" {
+		t.Fatal("late failure overwrote replacement")
+	}
+	endpoint.Close()
+	endpoint.readerFailed(old+1, syscall.EIO)
+	if endpoint.ReaderState().State != "stopped" {
+		t.Fatal("late failure overwrote stop")
+	}
+}
+func TestTivraReaderLifecycleConcurrentSnapshots(t *testing.T) {
+	endpoint := &LinkEndpoint{device: &readerTestDevice{events: make(chan readerTestEvent, 4)}}
+	defer endpoint.Close()
+	var workers sync.WaitGroup
+	for i := 0; i < 8; i++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			for j := 0; j < 100; j++ {
+				endpoint.Attach(&readerTestDispatcher{})
+				_ = endpoint.ReaderState()
+				_ = endpoint.IsAttached()
+				endpoint.Close()
+			}
+		}()
+	}
+	workers.Wait()
+	if endpoint.ReaderState().State != "stopped" {
+		t.Fatal("not stopped")
+	}
+}
--- /dev/null
+++ b/proxy/tun/tivra_udp_association_test.go
@@ -0,0 +1,153 @@
+package tun
+
+import (
+	"bytes"
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/xtls/xray-core/common/buf"
+	"github.com/xtls/xray-core/common/net"
+	"github.com/xtls/xray-core/common/protocol"
+	"github.com/xtls/xray-core/proxy/vless/encoding"
+)
+
+func nextUDPTestConn(t *testing.T, c <-chan *udpConn) *udpConn {
+	t.Helper()
+	select {
+	case v := <-c:
+		return v
+	case <-time.After(time.Second):
+		t.Fatal("missing UDP association")
+		return nil
+	}
+}
+func TestTivraFixedDestinationUDPAssociations(t *testing.T) {
+	for _, test := range []struct {
+		name, first, second string
+		port                net.Port
+	}{
+		{"dns-v4", "1.1.1.1", "9.9.9.9", 53}, {"quic-v4", "1.1.1.1", "9.9.9.9", 443},
+		{"dns-v6", "2606:4700:4700::1111", "2620:fe::fe", 53}, {"quic-v6", "2606:4700:4700::1111", "2620:fe::fe", 443},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			connections := make(chan *udpConn, 4)
+			responseSources := make(chan net.Destination, 4)
+			handler := newUdpConnectionHandler(func(c net.Conn, _ net.Destination) { connections <- c.(*udpConn) }, func(_ []byte, src, dst net.Destination) error { responseSources <- src; return nil })
+			source := net.UDPDestination(net.ParseAddress("198.18.0.1"), 40000)
+			targets := []net.Destination{net.UDPDestination(net.ParseAddress(test.first), test.port), net.UDPDestination(net.ParseAddress(test.second), test.port)}
+			for _, target := range targets {
+				handler.HandlePacket(source, target, []byte("query"))
+			}
+			seen := map[net.Destination]bool{}
+			for range targets {
+				c := nextUDPTestConn(t, connections)
+				defer c.Close()
+				seen[c.dst] = true
+				mb, err := c.ReadMultiBuffer()
+				if err != nil || mb[0].UDP == nil || *mb[0].UDP != c.dst {
+					t.Fatal("wrong packet destination")
+				}
+				// The actual plain VLESS encoder drops per-packet address metadata;
+				// each native association must already carry the correct target.
+				request := &protocol.RequestHeader{Command: protocol.RequestCommandUDP, Address: c.dst.Address, Port: c.dst.Port}
+				var wire bytes.Buffer
+				writer := encoding.EncodeBodyAddons(buf.NewWriter(&wire), request, &encoding.Addons{}, nil, true, context.Background(), nil, nil)
+				if err = writer.WriteMultiBuffer(mb); err != nil {
+					t.Fatal(err)
+				}
+				reader := encoding.DecodeBodyAddons(bytes.NewReader(wire.Bytes()), request, &encoding.Addons{})
+				response, err := reader.ReadMultiBuffer()
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err = c.WriteMultiBuffer(response); err != nil {
+					t.Fatal(err)
+				}
+				if <-responseSources != c.dst {
+					t.Fatal("response source does not match intended target")
+				}
+			}
+			if len(seen) != 2 || !seen[targets[0]] || !seen[targets[1]] {
+				t.Fatal("different DNS/QUIC targets aliased")
+			}
+		})
+	}
+}
+func TestTivraOtherUDPStillUsesFullConeAndPreservesPacketDestination(t *testing.T) {
+	connections := make(chan *udpConn, 4)
+	handler := newUdpConnectionHandler(func(c net.Conn, _ net.Destination) { connections <- c.(*udpConn) }, func([]byte, net.Destination, net.Destination) error { return nil })
+	source := net.UDPDestination(net.ParseAddress("198.18.0.1"), 40000)
+	first := net.UDPDestination(net.ParseAddress("1.1.1.1"), 3478)
+	second := net.UDPDestination(net.ParseAddress("9.9.9.9"), 9999)
+	handler.HandlePacket(source, first, []byte("one"))
+	c := nextUDPTestConn(t, connections)
+	defer c.Close()
+	handler.HandlePacket(source, second, []byte("two"))
+	handler.RLock()
+	count := len(handler.udpConns)
+	handler.RUnlock()
+	if count != 1 {
+		t.Fatal("ordinary FullCone partition changed")
+	}
+	for _, want := range []net.Destination{first, second} {
+		mb, err := c.ReadMultiBuffer()
+		if err != nil || mb[0].UDP == nil || *mb[0].UDP != want {
+			t.Fatal("packet target lost")
+		}
+		buf.ReleaseMulti(mb)
+	}
+}
+func TestTivraUDPKeysAndDoubleCloseDoNotDeleteOtherAssociations(t *testing.T) {
+	connections := make(chan *udpConn, 8)
+	handler := newUdpConnectionHandler(func(c net.Conn, _ net.Destination) { connections <- c.(*udpConn) }, func([]byte, net.Destination, net.Destination) error { return nil })
+	source := net.UDPDestination(net.ParseAddress("198.18.0.1"), 40000)
+	first := net.UDPDestination(net.ParseAddress("1.1.1.1"), 53)
+	other := net.UDPDestination(net.ParseAddress("9.9.9.9"), 53)
+	handler.HandlePacket(source, first, []byte("a"))
+	old := nextUDPTestConn(t, connections)
+	handler.HandlePacket(source, other, []byte("b"))
+	second := nextUDPTestConn(t, connections)
+	defer second.Close()
+	old.Close()
+	handler.HandlePacket(source, first, []byte("c"))
+	replacement := nextUDPTestConn(t, connections)
+	defer replacement.Close()
+	old.Close()
+	handler.RLock()
+	defer handler.RUnlock()
+	if handler.udpConns[associationKey(source, first)] != replacement || handler.udpConns[associationKey(source, other)] != second {
+		t.Fatal("old close removed replacement or other destination")
+	}
+	if associationKey(source, first) == associationKey(net.UDPDestination(source.Address, 40001), first) {
+		t.Fatal("source ports alias")
+	}
+	if associationKey(source, first) == associationKey(source, net.UDPDestination(first.Address, 443)) {
+		t.Fatal("DNS and QUIC alias")
+	}
+}
+func TestTivraUDPConcurrentHandleAndClose(t *testing.T) {
+	var callbacks sync.WaitGroup
+	handler := newUdpConnectionHandler(func(c net.Conn, _ net.Destination) { defer callbacks.Done(); c.Close(); c.Close() }, func([]byte, net.Destination, net.Destination) error { return nil })
+	// Count handler creation in the callback-free wrapper to avoid WaitGroup Add
+	// racing Wait: wait only after all HandlePacket callers have completed.
+	original := handler.handleConnection
+	handler.handleConnection = func(c net.Conn, d net.Destination) { callbacks.Add(1); original(c, d) }
+	var writers sync.WaitGroup
+	for worker := 0; worker < 8; worker++ {
+		writers.Add(1)
+		go func(worker int) {
+			defer writers.Done()
+			for i := 0; i < 100; i++ {
+				source := net.UDPDestination(net.ParseAddress("198.18.0.1"), net.Port(40000+worker))
+				target := net.UDPDestination(net.ParseAddress("1.1.1.1"), net.Port(53+(i%2)*390))
+				handler.HandlePacket(source, target, []byte("q"))
+			}
+		}(worker)
+	}
+	writers.Wait()
+	// Map must settle empty; this also waits for callbacks not yet scheduled.
+	waitReaderTest(t, func() bool { handler.RLock(); defer handler.RUnlock(); return len(handler.udpConns) == 0 })
+	callbacks.Wait()
+}
