diff --git a/SVSim.UnitTests/BattleNode/Integration/BattleNodeFlowTests.cs b/SVSim.UnitTests/BattleNode/Integration/BattleNodeFlowTests.cs
new file mode 100644
index 0000000..2d58e42
--- /dev/null
+++ b/SVSim.UnitTests/BattleNode/Integration/BattleNodeFlowTests.cs
@@ -0,0 +1,73 @@
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.DependencyInjection;
+using NUnit.Framework;
+using SVSim.BattleNode.Bridge;
+using SVSim.BattleNode.Protocol;
+using SVSim.BattleNode.Wire;
+using SVSim.EmulatedEntrypoint;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.BattleNode.Integration;
+
+[TestFixture]
+public class BattleNodeFlowTests
+{
+    /// <summary>
+    /// End-to-end smoke for the v1 scripted lifecycle. Boots the EmulatedEntrypoint via
+    /// SVSimTestFactory (in-memory SQLite + reference-data CSV import), mints a battle
+    /// through IMatchingBridge, opens a raw Socket.IO v2 client against the in-process
+    /// TestServer, and drives InitNetwork → Loaded → Swap, asserting the right scripted
+    /// frames come back in order.
+    /// </summary>
+    [Test]
+    [Timeout(30000)]
+    public async Task ClientWalksHandshakeToReady_ReceivesAllScriptedFrames()
+    {
+        await using var factory = new SVSimTestFactory();
+        var bridge = factory.Services.GetRequiredService<IMatchingBridge>();
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
+        var ct = cts.Token;
+        var pending = bridge.RegisterPendingBattle(viewerId: 906243102);
+
+        var key = MakeKey();
+        var encryptedVid = NodeCrypto.EncryptForNode("906243102", key);
+        // TestServer ignores the host portion of the URI — only the path + query route.
+        var wsUri = new Uri($"ws://localhost/socket.io/?BattleId={pending.BattleId}&viewerId={Uri.EscapeDataString(encryptedVid)}&EIO=3&transport=websocket");
+
+        var wsClient = factory.Server.CreateWebSocketClient();
+        var ws = await wsClient.ConnectAsync(wsUri, ct);
+        await using var client = new RawSocketIoTestClient(ws);
+        await client.ConsumeHandshakeAsync(ct);
+
+        // 1. InitNetwork → expect InitNetwork ack push, then Matched, then BattleStart.
+        await client.SendMsgAsync(MakeEnvelope(NetworkBattleUri.InitNetwork, pubSeq: 1), key, ct);
+        var f1 = await client.ReceiveSynchronizeAsync(ct);
+        var f2 = await client.ReceiveSynchronizeAsync(ct);
+        var f3 = await client.ReceiveSynchronizeAsync(ct);
+        Assert.That(f1.Uri, Is.EqualTo(NetworkBattleUri.InitNetwork));
+        Assert.That(f2.Uri, Is.EqualTo(NetworkBattleUri.Matched));
+        Assert.That(f3.Uri, Is.EqualTo(NetworkBattleUri.BattleStart));
+
+        // 2. Loaded → expect Deal.
+        await client.SendMsgAsync(MakeEnvelope(NetworkBattleUri.Loaded, pubSeq: 2), key, ct);
+        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.Deal));
+
+        // 3. Swap with empty idxList → expect Swap response + Ready.
+        await client.SendMsgAsync(MakeEnvelope(NetworkBattleUri.Swap, pubSeq: 3,
+            body: new Dictionary<string, object?> { ["idxList"] = new List<object?>() }), key, ct);
+        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.Swap));
+        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.Ready));
+    }
+
+    private static MsgEnvelope MakeEnvelope(NetworkBattleUri uri, long pubSeq, Dictionary<string, object?>? body = null) =>
+        new(uri, ViewerId: 906243102, Uuid: "udid-test", Bid: null, Try: 0,
+            Cat: uri == NetworkBattleUri.InitNetwork ? EmitCategory.General : EmitCategory.Battle,
+            PubSeq: pubSeq, PlaySeq: null, Body: body ?? new Dictionary<string, object?>());
+
+    private static string MakeKey()
+    {
+        var seq = 0;
+        return NodeCrypto.GenerateKey(() => (seq++ * 13) % 16);
+    }
+}
diff --git a/SVSim.UnitTests/BattleNode/Integration/RawSocketIoTestClient.cs b/SVSim.UnitTests/BattleNode/Integration/RawSocketIoTestClient.cs
new file mode 100644
index 0000000..961c554
--- /dev/null
+++ b/SVSim.UnitTests/BattleNode/Integration/RawSocketIoTestClient.cs
@@ -0,0 +1,118 @@
+using System.Net.WebSockets;
+using System.Text;
+using MessagePack;
+using SVSim.BattleNode.Protocol;
+using SVSim.BattleNode.Wire;
+
+namespace SVSim.UnitTests.BattleNode.Integration;
+
+/// <summary>
+/// Minimal raw-WS Socket.IO v2 client for integration testing. Knows enough to send msg events
+/// with one binary attachment, receive synchronize pushes, and ack-callback echo. Takes a
+/// connected <see cref="WebSocket"/> (typically from <c>TestServer.CreateWebSocketClient()</c>).
+/// </summary>
+internal sealed class RawSocketIoTestClient : IAsyncDisposable
+{
+    private readonly WebSocket _ws;
+    private int _nextAckId = 1;
+
+    public RawSocketIoTestClient(WebSocket connectedWebSocket) => _ws = connectedWebSocket;
+
+    public async Task ConsumeHandshakeAsync(CancellationToken ct = default)
+    {
+        // Receive and discard the EIO Open frame the server sent on connect.
+        await ReceiveTextAsync(ct);
+    }
+
+    public async Task<MsgEnvelope> ReceiveSynchronizeAsync(CancellationToken ct = default)
+    {
+        while (true)
+        {
+            var text = await ReceiveTextAsync(ct);
+            var eio = EngineIoFrame.Parse(text);
+            if (eio.Type == EngineIoPacketType.Ping)
+            {
+                await SendTextAsync("3", ct);
+                continue;
+            }
+            if (eio.Type != EngineIoPacketType.Message) continue;
+
+            var sioHeader = SocketIoFrame.Parse(eio.Payload);
+            if (sioHeader.AttachmentCount == 0)
+            {
+                // Could be an ack — ignore.
+                continue;
+            }
+            var attachments = new List<byte[]>();
+            for (var i = 0; i < sioHeader.AttachmentCount; i++)
+                attachments.Add(await ReceiveBinaryAsync(ct));
+
+            var assembled = sioHeader.WithAttachments(attachments);
+            return MsgPayloadCodec.Decode(assembled.BinaryAttachments[0]);
+        }
+    }
+
+    public async Task SendMsgAsync(MsgEnvelope env, string key, CancellationToken ct = default)
+    {
+        var bytes = MsgPayloadCodec.Encode(env, key);
+        var sio = SocketIoFrame.BinaryEventWithAttachments("msg", new[] { bytes });
+        var (text, bins) = sio.Encode();
+        // Insert ack id for ackable emits (those with pubSeq).
+        if (env.PubSeq.HasValue)
+        {
+            var id = _nextAckId++;
+            // Re-encode with ackId by hand: type + N + - + id + json
+            text = $"5{bins.Count}-{id}{text.Substring(text.IndexOf('['))}";
+        }
+        await SendTextAsync($"{(int)EngineIoPacketType.Message}{text}", ct);
+        foreach (var b in bins)
+            await _ws.SendAsync(b, WebSocketMessageType.Binary, true, ct);
+    }
+
+    private async Task<string> ReceiveTextAsync(CancellationToken ct)
+    {
+        using var ms = new MemoryStream();
+        var buffer = new byte[8192];
+        WebSocketReceiveResult result;
+        do
+        {
+            result = await _ws.ReceiveAsync(buffer, ct);
+            ms.Write(buffer, 0, result.Count);
+        } while (!result.EndOfMessage);
+        return Encoding.UTF8.GetString(ms.ToArray());
+    }
+
+    private async Task<byte[]> ReceiveBinaryAsync(CancellationToken ct)
+    {
+        using var ms = new MemoryStream();
+        var buffer = new byte[8192];
+        WebSocketReceiveResult result;
+        do
+        {
+            result = await _ws.ReceiveAsync(buffer, ct);
+            ms.Write(buffer, 0, result.Count);
+        } while (!result.EndOfMessage);
+        return ms.ToArray();
+    }
+
+    private Task SendTextAsync(string text, CancellationToken ct)
+    {
+        var bytes = Encoding.UTF8.GetBytes(text);
+        return _ws.SendAsync(bytes, WebSocketMessageType.Text, true, ct);
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        // TestServer's in-process WebSocket doesn't always complete the graceful Close
+        // handshake — it can hang the test host shutdown. Abrupt dispose is fine for tests:
+        // the server-side ReceiveAsync throws WebSocketException, BattleSession.RunAsync
+        // returns, and the handler completes.
+        _ws.Dispose();
+        return ValueTask.CompletedTask;
+    }
+}
+
+// Note on attachments: the SocketIO v2 protocol can split binary attachments across multiple WS
+// frames, but in practice BestHTTP / our codec emits one attachment per binary WS frame, so the
+// receive loop assumes that ordering. If integration tests start to flake on multi-attachment
+// pushes, revisit ReceiveBinaryAsync to handle multi-frame attachments.