Add debug logging for socket.io room membership

Track socket joins and broadcasts to diagnose why playerJoined
events are not being received by other players in the same room.

Co-Authored-By: Claude <noreply@anthropic.com>

trigo-web/.env

@@ -14,6 +14,7 @@
 # ============================================================================
 
 # Backend Server URL
+VITE_SERVER_URL=http://localhost:8157
 
 # Vite Dev Server Configuration
 VITE_HOST=0.0.0.0
@@ -38,7 +39,7 @@ PORT=3000
 CLIENT_URL=http://localhost:5173
 
 # Environment mode
-NODE_ENV=production
+NODE_ENV=development
 
 
 # ============================================================================

trigo-web/app/package.json

@@ -1,32 +1,30 @@
 {
-  "name": "trigo-app",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "dev:host": "vite --host",
-    "build": "vite build",
-    "preview": "vite preview"
-  },
-  "dependencies": {
-    "d3": "^7.9.0",
-    "d3-scale-chromatic": "^3.1.0",
-    "pinia": "^2.1.6",
-    "socket.io-client": "^4.5.2",
-    "three": "^0.156.1",
-    "vue": "^3.3.4",
-    "vue-router": "^4.2.4",
-    "onnxruntime-web": "^1.23.2"
-  },
-  "devDependencies": {
-    "@types/d3": "^7.4.3",
-    "@types/three": "^0.156.0",
-    "@vitejs/plugin-vue": "^5.2.4",
-    "sass-embedded": "^1.93.2",
-    "typescript": "^5.2.2",
-    "vite": "^5.4.21",
-    "vue-tsc": "^2.2.12",
-    "@types/node": "^24.10.1"
-  }
+	"name": "trigo-app",
+	"private": true,
+	"version": "0.0.0",
+	"type": "module",
+	"scripts": {
+		"dev": "vite",
+		"dev:host": "vite --host",
+		"build": "vue-tsc --noEmit && vite build",
+		"preview": "vite preview"
+	},
+	"dependencies": {
+		"d3": "^7.9.0",
+		"d3-scale-chromatic": "^3.1.0",
+		"pinia": "^2.1.6",
+		"socket.io-client": "^4.5.2",
+		"three": "^0.156.1",
+		"vue": "^3.3.4",
+		"vue-router": "^4.2.4"
+	},
+	"devDependencies": {
+		"@types/d3": "^7.4.3",
+		"@types/three": "^0.156.0",
+		"@vitejs/plugin-vue": "^5.2.4",
+		"sass-embedded": "^1.93.2",
+		"typescript": "^5.2.2",
+		"vite": "^5.4.21",
+		"vue-tsc": "^2.2.12"
+	}
 }

trigo-web/app/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "module": "ESNext",
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "preserve",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-
-    /* Path aliases */
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"],
-      "@inc/*": ["../inc/*"]
-    }
-  },
-  "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"]
-}

trigo-web/app/tsconfig.node.json

@@ -1,10 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["vite.config.ts"]
-}

trigo-web/backend/.env.local

@@ -0,0 +1,2 @@
+
+PORT=8157

trigo-web/backend/package.json

@@ -3,11 +3,11 @@
 	"version": "1.0.0",
 	"type": "module",
 	"description": "Backend server for Trigo game",
-	"main": "dist/server.js",
+	"main": "dist/backend/src/server.js",
 	"scripts": {
 		"dev": "nodemon --watch src --exec tsx src/server.ts",
 		"build": "tsc",
-		"start": "node dist/server.js",
+		"start": "node dist/backend/src/server.js",
 		"test": "echo \"Error: no test specified\" && exit 1"
 	},
 	"keywords": [

trigo-web/backend/src/server.ts

@@ -69,7 +69,7 @@ app.use(express.json());
 
 // Serve static files from frontend build (for production)
 if (process.env.NODE_ENV === "production") {
-	const frontendPath = path.join(__dirname, "../../app/dist");
+	const frontendPath = path.join(__dirname, "../../../../app/dist");
 	app.use(express.static(frontendPath));
 
 	// Serve index.html for all routes (SPA support)

trigo-web/backend/src/sockets/gameSocket.ts

@@ -83,6 +83,11 @@ export function setupSocketHandlers(io: Server, socket: Socket, gameManager: Gam
 				if (room) {
 					socket.join(room.id);
 
+					// Debug: Log socket.io room membership
+					const roomSockets = io.sockets.adapter.rooms.get(room.id);
+					console.log(`[gameSocket] Socket ${socket.id} joined room ${room.id}`);
+					console.log(`[gameSocket] Room ${room.id} now has sockets:`, roomSockets ? Array.from(roomSockets) : []);
+
 					// Get complete game data for frontend
 					const currentPlayer = gameManager.getCurrentPlayer(room.id);
 					const stats = gameManager.getGameStats(room.id);
@@ -133,10 +138,12 @@ export function setupSocketHandlers(io: Server, socket: Socket, gameManager: Gam
 					}
 
 					// Notify other players
+					console.log(`[gameSocket] Broadcasting playerJoined to room ${room.id} (excluding ${socket.id})`);
 					socket.to(room.id).emit("playerJoined", {
 						playerId: socket.id,
 						nickname: nickname
 					});
+					console.log(`[gameSocket] playerJoined broadcast sent`);
 
 					// Broadcast room update to all sockets (for room list)
 					const roomSummary = getRoomSummary(room);

trigo-web/package.json

@@ -1,64 +1,65 @@
 {
-  "name": "trigo-web",
-  "version": "1.0.0",
-  "type": "module",
-  "description": "3D Go board game with Vue3 and Node.js",
-  "scripts": {
-    "dev": "concurrently \"npm run dev:backend\" \"npm run dev:app\"",
-    "dev:app": "cd app && npm run dev",
-    "dev:backend": "cd backend && npm run dev",
-    "build": "npm run build:app && npm run build:backend",
-    "build:app": "cd app && npm run build",
-    "build:backend": "cd backend && npm run build",
-    "build:parsers": "npm run build:parser:tgn",
-    "build:parser:tgn": "tsx tools/buildJisonParser.ts",
-    "install:all": "npm install && cd app && npm install && cd ../backend && npm install",
-    "start:prod": "cd backend && npm start",
-    "format": "prettier --write \"**/*.{js,ts,vue,json,md,scss,css}\"",
-    "format:check": "prettier --check \"**/*.{js,ts,vue,json,md,scss,css}\"",
-    "test": "vitest",
-    "test:ui": "vitest --ui",
-    "test:run": "vitest run",
-    "generate:games": "tsx tools/generateRandomGames.ts",
-    "migrate:tgn": "tsx tools/migrateTGN.ts"
-  },
-  "keywords": [
-    "game",
-    "go",
-    "3d",
-    "vue",
-    "nodejs",
-    "websocket"
-  ],
-  "author": "",
-  "license": "MIT",
-  "lint-staged": {
-    "**/*.{js,ts,vue,json,md,scss,css}": []
-  },
-  "devDependencies": {
-    "@types/node": "^24.10.0",
-    "@types/yargs": "^17.0.34",
-    "@vitejs/plugin-vue": "^5.2.4",
-    "@vitest/ui": "^4.0.6",
-    "concurrently": "^7.6.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
-    "husky": "^9.1.7",
-    "jison": "^0.4.18",
-    "jsdom": "^27.1.0",
-    "lint-staged": "^16.2.7",
-    "onnxruntime-node": "^1.23.2",
-    "onnxruntime-web": "1.23.2",
-    "prettier": "^3.6.2",
-    "tsx": "^4.20.6",
-    "typescript": "^5.2.2",
-    "vite": "^5.4.21",
-    "vitest": "^4.0.6",
-    "vue": "^3.3.4",
-    "vue-tsc": "^3.1.3",
-    "yargs": "^18.0.0"
-  },
-  "dependencies": {
-    "dotenv": "^17.2.3"
-  }
+	"name": "trigo-web",
+	"version": "1.0.0",
+	"type": "module",
+	"description": "3D Go board game with Vue3 and Node.js",
+	"scripts": {
+		"dev": "concurrently \"npm run dev:backend\" \"npm run dev:app\"",
+		"dev:app": "cd app && npm run dev",
+		"dev:backend": "cd backend && npm run dev",
+		"build": "npm run build:app && npm run build:backend",
+		"build:app": "cd app && npm run build",
+		"build:backend": "cd backend && npm run build",
+		"build:parsers": "npm run build:parser:tgn",
+		"build:parser:tgn": "tsx tools/buildJisonParser.ts",
+		"install:all": "npm install && cd app && npm install && cd ../backend && npm install",
+		"start:prod": "cd backend && npm start",
+		"format": "prettier --write \"**/*.{js,ts,vue,json,md,scss,css}\"",
+		"format:check": "prettier --check \"**/*.{js,ts,vue,json,md,scss,css}\"",
+		"test": "vitest",
+		"test:ui": "vitest --ui",
+		"test:run": "vitest run",
+		"generate:games": "tsx tools/generateRandomGames.ts",
+		"migrate:tgn": "tsx tools/migrateTGN.ts",
+		"prepare": "cd .. && husky"
+	},
+	"keywords": [
+		"game",
+		"go",
+		"3d",
+		"vue",
+		"nodejs",
+		"websocket"
+	],
+	"author": "",
+	"license": "MIT",
+	"lint-staged": {
+		"**/*.{js,ts,vue,json,md,scss,css}": []
+	},
+	"devDependencies": {
+		"@types/node": "^24.10.0",
+		"@types/yargs": "^17.0.34",
+		"@vitejs/plugin-vue": "^5.2.4",
+		"@vitest/ui": "^4.0.6",
+		"concurrently": "^7.6.0",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-prettier": "^5.5.4",
+		"husky": "^9.1.7",
+		"jison": "^0.4.18",
+		"jsdom": "^27.1.0",
+		"lint-staged": "^16.2.7",
+		"onnxruntime-node": "^1.23.2",
+		"onnxruntime-web": "1.23.2",
+		"prettier": "^3.6.2",
+		"tsx": "^4.20.6",
+		"typescript": "^5.2.2",
+		"vite": "^5.4.21",
+		"vitest": "^4.0.6",
+		"vue": "^3.3.4",
+		"vue-tsc": "^3.1.3",
+		"yargs": "^18.0.0"
+	},
+	"dependencies": {
+		"dotenv": "^17.2.3"
+	}
 }

trigo-web/tests/game/debug_capture.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from "vitest";
+import { TrigoGame, StoneType } from "@inc/trigo/game";
+
+describe("Debug Capture", () => {
+	it("debug 2D capture scenario", () => {
+		const game = new TrigoGame({ x: 5, y: 5, z: 1 });
+		game.startGame();
+
+		console.log("\n=== Testing 2D Capture ===");
+
+		// Check White stone at (3,2,0) neighbors
+		game.drop({ x: 2, y: 2, z: 0 }); // Black
+		game.drop({ x: 3, y: 2, z: 0 }); // White (target)
+		console.log("White placed at (3,2,0)");
+
+		game.drop({ x: 4, y: 2, z: 0 }); // Black (right of white)
+		console.log("After Black at (4,2,0) - right of white");
+
+		game.drop({ x: 3, y: 1, z: 0 }); // White elsewhere
+		game.drop({ x: 3, y: 3, z: 0 }); // Black (bottom of white)
+		console.log("After Black at (3,3,0) - bottom of white");
+
+		game.drop({ x: 1, y: 1, z: 0 }); // White elsewhere
+
+		console.log("\nBefore final move:");
+		console.log("  board[2][2][0] (left):", game.getBoard()[2][2][0], "BLACK=1");
+		console.log("  board[3][2][0] (white):", game.getBoard()[3][2][0], "WHITE=2");
+		console.log("  board[4][2][0] (right):", game.getBoard()[4][2][0], "BLACK=1");
+		console.log("  board[3][1][0] (top):", game.getBoard()[3][1][0], "WHITE=2");
+		console.log("  board[3][3][0] (bottom):", game.getBoard()[3][3][0], "BLACK=1");
+		console.log("  board[2][1][0] (top-left):", game.getBoard()[2][1][0], "EMPTY=0");
+
+		game.drop({ x: 2, y: 1, z: 0 }); // Black at (2,1,0) - top of white?
+
+		console.log("\nAfter final Black move at (2,1,0):");
+		console.log(
+			"  board[3][2][0]:",
+			game.getBoard()[3][2][0],
+			"(should be EMPTY=0 if captured)"
+		);
+		console.log("  Last step capturedPositions:", game.getLastStep()?.capturedPositions);
+		console.log("  Captured counts:", game.getCapturedCounts());
+	});
+});

trigo-web/tests/game/debug_redo.test.ts

@@ -0,0 +1,42 @@
+import { describe, it } from "vitest";
+import { TrigoGame, StoneType } from "@inc/trigo/game";
+
+describe("Debug Redo After Jump", () => {
+	it("trace redo behavior", () => {
+		const game = new TrigoGame({ x: 5, y: 5, z: 1 });
+		game.startGame();
+
+		console.log("\n=== Initial state ===");
+		console.log(`getCurrentStep: ${game.getCurrentStep()}`);
+		console.log(`history length: ${game.getHistory().length}`);
+		console.log(`Expected: step 0 means NO moves applied`);
+
+		console.log("\n=== After first drop (2,2,0) ===");
+		game.drop({ x: 2, y: 2, z: 0 });
+		console.log(`getCurrentStep: ${game.getCurrentStep()}`);
+		console.log(`history length: ${game.getHistory().length}`);
+		console.log(`board[2][2][0]: ${game.getBoard()[2][2][0]} (BLACK=1)`);
+
+		console.log("\n=== After second drop (3,2,0) ===");
+		game.drop({ x: 3, y: 2, z: 0 });
+		console.log(`getCurrentStep: ${game.getCurrentStep()}`);
+		console.log(`history length: ${game.getHistory().length}`);
+		console.log(`board[2][2][0]: ${game.getBoard()[2][2][0]}`);
+		console.log(`board[3][2][0]: ${game.getBoard()[3][2][0]} (WHITE=2)`);
+
+		console.log("\n=== After jumpToStep(0) ===");
+		game.jumpToStep(0);
+		console.log(`getCurrentStep: ${game.getCurrentStep()}`);
+		console.log(`history length: ${game.getHistory().length}`);
+		console.log(`board[2][2][0]: ${game.getBoard()[2][2][0]}`);
+		console.log(`board[3][2][0]: ${game.getBoard()[3][2][0]} (should be 0=EMPTY)`);
+		console.log(`canRedo: ${game.canRedo()}`);
+
+		console.log("\n=== After redo() ===");
+		const redoResult = game.redo();
+		console.log(`redo returned: ${redoResult}`);
+		console.log(`getCurrentStep: ${game.getCurrentStep()}`);
+		console.log(`board[2][2][0]: ${game.getBoard()[2][2][0]}`);
+		console.log(`board[3][2][0]: ${game.getBoard()[3][2][0]} (expected WHITE=2)`);
+	});
+});

trigo-web/tests/game/trigoGame.core.test.ts

@@ -0,0 +1,300 @@
+/**
+ * TrigoGame Core Functionality Tests
+ *
+ * Tests basic game operations: initialization, moves, pass, surrender
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { TrigoGame, StoneType } from "@inc/trigo/game";
+import type { BoardShape } from "@inc/trigo/types";
+
+describe("TrigoGame - Core Functionality", () => {
+	let game: TrigoGame;
+	const defaultShape: BoardShape = { x: 5, y: 5, z: 5 };
+
+	beforeEach(() => {
+		game = new TrigoGame(defaultShape);
+	});
+
+	describe("Initialization", () => {
+		it("should initialize with empty board", () => {
+			const board = game.getBoard();
+			expect(board).toBeDefined();
+			expect(board.length).toBe(5);
+			expect(board[0].length).toBe(5);
+			expect(board[0][0].length).toBe(5);
+		});
+
+		it("should start with black player", () => {
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK);
+		});
+
+		it("should have initial game status as idle", () => {
+			expect(game.getGameStatus()).toBe("idle");
+		});
+
+		it("should have no moves initially", () => {
+			expect(game.getCurrentStep()).toBe(0);
+			expect(game.getHistory().length).toBe(0);
+		});
+
+		it("should initialize with correct board shape", () => {
+			const shape = game.getShape();
+			expect(shape).toEqual(defaultShape);
+		});
+	});
+
+	describe("Start Game", () => {
+		it("should change status from idle to playing", () => {
+			game.startGame();
+			expect(game.getGameStatus()).toBe("playing");
+		});
+
+		it("should not start if already playing", () => {
+			game.startGame();
+			expect(game.getGameStatus()).toBe("playing");
+			game.startGame(); // Try starting again
+			expect(game.getGameStatus()).toBe("playing");
+		});
+	});
+
+	describe("Drop Stone", () => {
+		beforeEach(() => {
+			game.startGame();
+		});
+
+		it("should place a black stone at position", () => {
+			const success = game.drop({ x: 2, y: 2, z: 2 });
+			expect(success).toBe(true);
+
+			const board = game.getBoard();
+			expect(board[2][2][2]).toBe(StoneType.BLACK);
+		});
+
+		it("should switch to white player after black moves", () => {
+			game.drop({ x: 2, y: 2, z: 2 });
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE);
+		});
+
+		it("should increment step count", () => {
+			expect(game.getCurrentStep()).toBe(0);
+			game.drop({ x: 2, y: 2, z: 2 });
+			expect(game.getCurrentStep()).toBe(1);
+		});
+
+		it("should add move to history", () => {
+			game.drop({ x: 2, y: 2, z: 2 });
+			const history = game.getHistory();
+			expect(history.length).toBe(1);
+			expect(history[0].position).toEqual({ x: 2, y: 2, z: 2 });
+			expect(history[0].player).toBe(StoneType.BLACK);
+		});
+
+		it("should not place stone on occupied position", () => {
+			game.drop({ x: 2, y: 2, z: 2 });
+			const success = game.drop({ x: 2, y: 2, z: 2 });
+			expect(success).toBe(false);
+		});
+
+		it("should not place stone out of bounds", () => {
+			const success = game.drop({ x: 10, y: 10, z: 10 });
+			expect(success).toBe(false);
+		});
+
+		it("should allow alternating moves", () => {
+			game.drop({ x: 2, y: 2, z: 2 }); // Black
+			game.drop({ x: 3, y: 2, z: 2 }); // White
+			game.drop({ x: 2, y: 3, z: 2 }); // Black
+
+			const board = game.getBoard();
+			expect(board[2][2][2]).toBe(StoneType.BLACK);
+			expect(board[3][2][2]).toBe(StoneType.WHITE);
+			expect(board[2][3][2]).toBe(StoneType.BLACK);
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE);
+		});
+
+		it("should reset pass count when stone is placed", () => {
+			game.pass(); // Black passes
+			expect(game.getPassCount()).toBe(1);
+			game.drop({ x: 2, y: 2, z: 2 }); // White places stone
+			expect(game.getPassCount()).toBe(0);
+		});
+	});
+
+	describe("Pass", () => {
+		beforeEach(() => {
+			game.startGame();
+		});
+
+		it("should allow player to pass", () => {
+			const success = game.pass();
+			expect(success).toBe(true);
+		});
+
+		it("should switch player after pass", () => {
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK);
+			game.pass();
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE);
+		});
+
+		it("should increment pass count", () => {
+			expect(game.getPassCount()).toBe(0);
+			game.pass();
+			expect(game.getPassCount()).toBe(1);
+		});
+
+		it("should add pass to history", () => {
+			game.pass();
+			const history = game.getHistory();
+			expect(history.length).toBe(1);
+			expect(history[0].type).toBe(1); // StepType.PASS
+		});
+
+		it("should end game after two consecutive passes", () => {
+			game.pass(); // Black passes
+			game.pass(); // White passes
+
+			expect(game.getGameStatus()).toBe("finished");
+			expect(game.getGameResult()).toBeDefined();
+			expect(game.getGameResult()?.reason).toBe("double-pass");
+		});
+
+		it("should not end game if pass not consecutive", () => {
+			game.pass(); // Black passes
+			game.drop({ x: 2, y: 2, z: 2 }); // White places stone
+			game.pass(); // Black passes again
+
+			expect(game.getGameStatus()).toBe("playing");
+		});
+	});
+
+	describe("Surrender", () => {
+		beforeEach(() => {
+			game.startGame();
+		});
+
+		it("should allow player to surrender", () => {
+			const success = game.surrender();
+			expect(success).toBe(true);
+		});
+
+		it("should end the game", () => {
+			game.surrender();
+			expect(game.getGameStatus()).toBe("finished");
+		});
+
+		it("should set winner as opponent", () => {
+			// Black surrenders
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK);
+			game.surrender();
+
+			const result = game.getGameResult();
+			expect(result).toBeDefined();
+			expect(result?.winner).toBe("white");
+			expect(result?.reason).toBe("resignation");
+		});
+
+		it("should add surrender to history", () => {
+			game.surrender();
+			const history = game.getHistory();
+			expect(history.length).toBe(1);
+			expect(history[0].type).toBe(2); // StepType.SURRENDER
+		});
+	});
+
+	describe("Reset", () => {
+		it("should reset game to initial state", () => {
+			game.startGame();
+			game.drop({ x: 2, y: 2, z: 2 });
+			game.drop({ x: 3, y: 2, z: 2 });
+			game.pass();
+
+			game.reset();
+
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK);
+			expect(game.getCurrentStep()).toBe(0);
+			expect(game.getHistory().length).toBe(0);
+			expect(game.getGameStatus()).toBe("idle");
+			expect(game.getPassCount()).toBe(0);
+
+			// Board should be empty
+			const board = game.getBoard();
+			for (let x = 0; x < 5; x++) {
+				for (let y = 0; y < 5; y++) {
+					for (let z = 0; z < 5; z++) {
+						expect(board[x][y][z]).toBe(StoneType.EMPTY);
+					}
+				}
+			}
+		});
+	});
+
+	describe("Getters", () => {
+		beforeEach(() => {
+			game.startGame();
+		});
+
+		it("should get stone at position", () => {
+			game.drop({ x: 2, y: 2, z: 2 });
+			const stone = game.getStone({ x: 2, y: 2, z: 2 });
+			expect(stone).toBe(StoneType.BLACK);
+		});
+
+		it("should return EMPTY for empty position", () => {
+			const stone = game.getStone({ x: 2, y: 2, z: 2 });
+			expect(stone).toBe(StoneType.EMPTY);
+		});
+
+		it("should get last step", () => {
+			game.drop({ x: 2, y: 2, z: 2 });
+			const lastStep = game.getLastStep();
+			expect(lastStep).toBeDefined();
+			expect(lastStep?.position).toEqual({ x: 2, y: 2, z: 2 });
+		});
+
+		it("should return null for last step when no moves", () => {
+			const lastStep = game.getLastStep();
+			expect(lastStep).toBeNull();
+		});
+
+		it("should get captured counts", () => {
+			const counts = game.getCapturedCounts();
+			expect(counts).toEqual({ black: 0, white: 0 });
+		});
+
+		it("should get game stats", () => {
+			game.drop({ x: 2, y: 2, z: 2 }); // Black
+			game.drop({ x: 3, y: 2, z: 2 }); // White
+
+			const stats = game.getStats();
+			expect(stats.totalMoves).toBe(2);
+			expect(stats.blackMoves).toBe(1);
+			expect(stats.whiteMoves).toBe(1);
+			expect(stats.territory).toBeDefined();
+		});
+	});
+
+	describe("Validation", () => {
+		beforeEach(() => {
+			game.startGame();
+		});
+
+		it("should validate valid move", () => {
+			const result = game.isValidMove({ x: 2, y: 2, z: 2 });
+			expect(result.valid).toBe(true);
+		});
+
+		it("should invalidate out of bounds move", () => {
+			const result = game.isValidMove({ x: 10, y: 10, z: 10 });
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("out of bounds");
+		});
+
+		it("should invalidate occupied position", () => {
+			game.drop({ x: 2, y: 2, z: 2 });
+			const result = game.isValidMove({ x: 2, y: 2, z: 2 });
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("occupied");
+		});
+	});
+});

trigo-web/tests/game/trigoGame.fromTGN.test.ts

@@ -0,0 +1,319 @@
+/**
+ * Tests for TrigoGame.fromTGN() - TGN Import Functionality
+ */
+
+import { describe, it, expect, beforeAll } from "vitest";
+import { TrigoGame, StoneType, validateTGN, TGNParseError } from "@inc/trigo/game";
+import { initializeParsers } from "@inc/trigo/parserInit";
+
+describe("TrigoGame.fromTGN() - TGN Import", () => {
+	// Initialize parsers before running tests
+	beforeAll(async () => {
+		await initializeParsers();
+	});
+
+	describe("Basic TGN Parsing", () => {
+		it("should parse empty TGN with default board", () => {
+			const tgn = ``;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getShape()).toEqual({ x: 5, y: 5, z: 5 });
+			expect(game.getGameStatus()).toBe("playing");
+			expect(game.getHistory()).toHaveLength(0);
+		});
+
+		it("should parse TGN with only metadata", () => {
+			const tgn = `
+[Event "Test Game"]
+[Black "Alice"]
+[White "Bob"]
+[Board 5x5x5]
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getShape()).toEqual({ x: 5, y: 5, z: 5 });
+			expect(game.getGameStatus()).toBe("playing");
+		});
+
+		it("should parse TGN with 3x3x3 board", () => {
+			const tgn = `[Board 3x3x3]`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getShape()).toEqual({ x: 3, y: 3, z: 3 });
+		});
+
+		it("should parse TGN with 2D board (19x19)", () => {
+			const tgn = `[Board 19x19]`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getShape()).toEqual({ x: 19, y: 19, z: 1 });
+		});
+	});
+
+	describe("Move Parsing", () => {
+		it("should parse and replay simple move sequence", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. 000 y00
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getHistory()).toHaveLength(2);
+
+			// Check first move (black at center)
+			const board = game.getBoard();
+			expect(board[2][2][2]).toBe(StoneType.BLACK); // 000
+
+			// Check second move (white at y=3, 0=2, 0=2)
+			expect(board[3][2][2]).toBe(StoneType.WHITE); // y00 = [3,2,2]
+		});
+
+		it("should parse multiple rounds", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. 000 y00
+2. 0aa zyy
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getHistory()).toHaveLength(4);
+
+			const board = game.getBoard();
+			expect(board[2][2][2]).toBe(StoneType.BLACK); // 000 = [2,2,2]
+			expect(board[3][2][2]).toBe(StoneType.WHITE); // y00 = [3,2,2]
+			expect(board[2][0][0]).toBe(StoneType.BLACK); // 0aa = [2,0,0]
+			expect(board[4][3][3]).toBe(StoneType.WHITE); // zyy = [4,3,3]
+		});
+
+		it("should parse pass move", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. 000 Pass
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getHistory()).toHaveLength(2);
+
+			const history = game.getHistory();
+			expect(history[0].position).toEqual({ x: 2, y: 2, z: 2 });
+			expect(history[1].position).toBeUndefined();
+		});
+
+		it("should parse resign move", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. 000 Resign
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getHistory()).toHaveLength(2);
+			expect(game.getGameStatus()).toBe("finished");
+		});
+
+		it("should handle incomplete round (black only)", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. 000 y00
+2. 0aa
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getHistory()).toHaveLength(3);
+
+			const board = game.getBoard();
+			expect(board[2][2][2]).toBe(StoneType.BLACK); // 000 = [2,2,2]
+			expect(board[3][2][2]).toBe(StoneType.WHITE); // y00 = [3,2,2]
+			expect(board[2][0][0]).toBe(StoneType.BLACK); // 0aa = [2,0,0]
+		});
+	});
+
+	describe("2D Board Games", () => {
+		it("should parse 2D game correctly", () => {
+			const tgn = `
+[Board 9x9]
+
+1. 00 y0
+2. 0a zy
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getShape()).toEqual({ x: 9, y: 9, z: 1 });
+			expect(game.getHistory()).toHaveLength(4);
+
+			const board = game.getBoard();
+			expect(board[4][4][0]).toBe(StoneType.BLACK); // 00 = [4,4,0] (center of 9x9)
+			expect(board[7][4][0]).toBe(StoneType.WHITE); // y0 = [7,4,0] (y=7 for 9x9)
+		});
+	});
+
+	describe("Complete Game Examples", () => {
+		it("should parse complete game with metadata and moves", () => {
+			const tgn = `
+[Event "World Championship"]
+[Site "Tokyo"]
+[Date "2025.10.31"]
+[Black "Alice"]
+[White "Bob"]
+[Board 5x5x5]
+[Rules "Chinese"]
+[Application "Trigo v1.0"]
+
+1. 000 y00
+2. 0y0 yy0
+3. aaa Pass
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getShape()).toEqual({ x: 5, y: 5, z: 5 });
+			expect(game.getHistory()).toHaveLength(6);
+
+			const board = game.getBoard();
+			expect(board[2][2][2]).toBe(StoneType.BLACK); // 000 = [2,2,2]
+			expect(board[3][2][2]).toBe(StoneType.WHITE); // y00 = [3,2,2]
+			expect(board[2][3][2]).toBe(StoneType.BLACK); // 0y0 = [2,3,2]
+			expect(board[3][3][2]).toBe(StoneType.WHITE); // yy0 = [3,3,2]
+			expect(board[0][0][0]).toBe(StoneType.BLACK); // aaa = [0,0,0]
+		});
+
+		it("should handle game with early resignation", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. 000 y00
+2. Resign
+`;
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getHistory()).toHaveLength(3);
+			expect(game.getGameStatus()).toBe("finished");
+
+			const result = game.getGameResult();
+			expect(result?.winner).toBe("white");
+			expect(result?.reason).toBe("resignation");
+		});
+	});
+
+	describe("TGN Validation", () => {
+		it("should validate correct TGN", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. 000 y00
+`;
+			const result = validateTGN(tgn);
+
+			expect(result.valid).toBe(true);
+			expect(result.error).toBeUndefined();
+		});
+
+		it("should detect invalid TGN", () => {
+			const tgn = `[Board invalid]`;
+			const result = validateTGN(tgn);
+
+			expect(result.valid).toBe(false);
+			expect(result.error).toBeDefined();
+		});
+
+		it("should throw TGNParseError on invalid input", () => {
+			const tgn = `[Invalid Tag Without Value`;
+
+			expect(() => TrigoGame.fromTGN(tgn)).toThrow();
+		});
+	});
+
+	describe("Roundtrip Testing", () => {
+		it("should roundtrip: export to TGN and reimport", () => {
+			// Create original game
+			const game1 = new TrigoGame({ x: 5, y: 5, z: 5 });
+			game1.startGame();
+			game1.drop({ x: 2, y: 2, z: 2 }); // 000
+			game1.drop({ x: 4, y: 2, z: 2 }); // y00
+			game1.drop({ x: 2, y: 4, z: 2 }); // 0y0
+			game1.pass();
+
+			// Export to TGN
+			const tgn = game1.toTGN({
+				event: "Roundtrip Test",
+				black: "Player 1",
+				white: "Player 2"
+			});
+
+			// Import from TGN
+			const game2 = TrigoGame.fromTGN(tgn);
+
+			// Verify board state matches
+			const board1 = game1.getBoard();
+			const board2 = game2.getBoard();
+
+			for (let x = 0; x < 5; x++) {
+				for (let y = 0; y < 5; y++) {
+					for (let z = 0; z < 5; z++) {
+						expect(board2[x][y][z]).toBe(board1[x][y][z]);
+					}
+				}
+			}
+
+			// Verify step history length
+			expect(game2.getHistory()).toHaveLength(game1.getHistory().length);
+		});
+
+		it("should roundtrip complex game", () => {
+			// Create a more complex game
+			const game1 = new TrigoGame({ x: 3, y: 3, z: 3 });
+			game1.startGame();
+
+			// Play several moves
+			game1.drop({ x: 1, y: 1, z: 1 }); // Center
+			game1.drop({ x: 0, y: 0, z: 0 });
+			game1.drop({ x: 2, y: 2, z: 2 });
+			game1.drop({ x: 0, y: 2, z: 0 });
+			game1.pass();
+			game1.drop({ x: 1, y: 0, z: 1 });
+
+			const tgn = game1.toTGN({
+				application: "Test Suite"
+			});
+
+			const game2 = TrigoGame.fromTGN(tgn);
+
+			// Boards should be identical
+			const board1 = game1.getBoard();
+			const board2 = game2.getBoard();
+
+			for (let x = 0; x < 3; x++) {
+				for (let y = 0; y < 3; y++) {
+					for (let z = 0; z < 3; z++) {
+						expect(board2[x][y][z]).toBe(board1[x][y][z]);
+					}
+				}
+			}
+		});
+	});
+
+	describe("Error Handling", () => {
+		it("should handle invalid coordinates gracefully", () => {
+			const tgn = `
+[Board 5x5x5]
+
+1. xyz 000
+`;
+			// Should throw an error during parsing (now synchronous)
+			expect(() => {
+				TrigoGame.fromTGN(tgn);
+			}).toThrow();
+		});
+
+		it("should handle invalid board shape", () => {
+			const tgn = `[Board notaboard]`;
+
+			// Parser should reject this
+			const result = validateTGN(tgn);
+			expect(result.valid).toBe(false);
+		});
+	});
+});

trigo-web/tests/game/trigoGame.history.test.ts

@@ -0,0 +1,301 @@
+/**
+ * TrigoGame History Management Tests
+ *
+ * Tests undo, redo, and jump-to-step functionality
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { TrigoGame, StoneType } from '@inc/trigo/game'
+import type { BoardShape } from '@inc/trigo/types'
+
+
+describe('TrigoGame - History Management', () => {
+	let game: TrigoGame
+	const defaultShape: BoardShape = { x: 5, y: 5, z: 1 }  // Use 2D board for capture tests
+
+	beforeEach(() => {
+		game = new TrigoGame(defaultShape)
+		game.startGame()
+	})
+
+
+	describe('Undo', () => {
+		it('should undo last move', () => {
+			game.drop({ x: 2, y: 2, z: 0 })
+			expect(game.getCurrentStep()).toBe(1)
+
+			const success = game.undo()
+			expect(success).toBe(true)
+			expect(game.getCurrentStep()).toBe(0)
+
+			const board = game.getBoard()
+			expect(board[2][2][0]).toBe(StoneType.EMPTY)
+		})
+
+		it('should restore previous player after undo', () => {
+			game.drop({ x: 2, y: 2, z: 0 }) // Black moves
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE)
+
+			game.undo()
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK)
+		})
+
+		it('should not undo when at start', () => {
+			const success = game.undo()
+			expect(success).toBe(false)
+		})
+
+		it('should undo multiple moves', () => {
+			game.drop({ x: 2, y: 2, z: 0 }) // Black
+			game.drop({ x: 3, y: 2, z: 0 }) // White
+			game.drop({ x: 2, y: 3, z: 0 }) // Black
+
+			expect(game.getCurrentStep()).toBe(3)
+
+			game.undo() // Undo black's move
+			expect(game.getCurrentStep()).toBe(2)
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK)
+
+			game.undo() // Undo white's move
+			expect(game.getCurrentStep()).toBe(1)
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE)
+
+			game.undo() // Undo black's move
+			expect(game.getCurrentStep()).toBe(0)
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK)
+		})
+
+		it('should undo pass move', () => {
+			game.pass()
+			expect(game.getCurrentStep()).toBe(1)
+			expect(game.getPassCount()).toBe(1)
+
+			game.undo()
+			expect(game.getCurrentStep()).toBe(0)
+			expect(game.getPassCount()).toBe(0)
+		})
+
+		it('should restore captured stones on undo', () => {
+			// Create a capture scenario: surround white stone with black
+			game.drop({ x: 2, y: 2, z: 0 }) // Black
+			game.drop({ x: 3, y: 2, z: 0 }) // White (target)
+			game.drop({ x: 4, y: 2, z: 0 }) // Black (surrounds white)
+			game.drop({ x: 0, y: 0, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 3, z: 0 }) // Black surrounds
+			game.drop({ x: 0, y: 1, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 1, z: 0 }) // Black surrounds
+
+			// White stone should be captured
+			let board = game.getBoard()
+			expect(board[3][2][0]).toBe(StoneType.EMPTY)
+
+			// Undo last move
+			game.undo()
+
+			// White stone should be restored
+			board = game.getBoard()
+			expect(board[3][2][0]).toBe(StoneType.WHITE)
+		})
+	})
+
+
+	describe('Redo', () => {
+		it('should redo undone move', () => {
+			game.drop({ x: 2, y: 2, z: 0 })
+			game.undo()
+
+			const success = game.redo()
+			expect(success).toBe(true)
+			expect(game.getCurrentStep()).toBe(1)
+
+			const board = game.getBoard()
+			expect(board[2][2][0]).toBe(StoneType.BLACK)
+		})
+
+		it('should not redo when at end of history', () => {
+			game.drop({ x: 2, y: 2, z: 0 })
+			const success = game.redo()
+			expect(success).toBe(false)
+		})
+
+		it('should redo multiple moves', () => {
+			game.drop({ x: 2, y: 2, z: 0 }) // Black
+			game.drop({ x: 3, y: 2, z: 0 }) // White
+			game.drop({ x: 2, y: 3, z: 0 }) // Black
+
+			game.undo()
+			game.undo()
+			game.undo()
+
+			expect(game.getCurrentStep()).toBe(0)
+
+			game.redo()
+			expect(game.getCurrentStep()).toBe(1)
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE)
+
+			game.redo()
+			expect(game.getCurrentStep()).toBe(2)
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK)
+
+			game.redo()
+			expect(game.getCurrentStep()).toBe(3)
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE)
+		})
+
+		it('should check canRedo correctly', () => {
+			expect(game.canRedo()).toBe(false)
+
+			game.drop({ x: 2, y: 2, z: 0 })
+			expect(game.canRedo()).toBe(false)
+
+			game.undo()
+			expect(game.canRedo()).toBe(true)
+
+			game.redo()
+			expect(game.canRedo()).toBe(false)
+		})
+
+		it('should truncate history when making new move after undo', () => {
+			game.drop({ x: 2, y: 2, z: 0 }) // Move 1
+			game.drop({ x: 3, y: 2, z: 0 }) // Move 2
+			game.drop({ x: 2, y: 3, z: 0 }) // Move 3
+
+			game.undo() // Back to move 2
+			game.undo() // Back to move 1
+
+			// Make a new move - should truncate moves 2 and 3
+			game.drop({ x: 4, y: 4, z: 0 })
+
+			expect(game.getCurrentStep()).toBe(2)
+			expect(game.canRedo()).toBe(false)
+
+			const history = game.getHistory()
+			expect(history.length).toBe(2)
+		})
+	})
+
+
+	describe('Jump to Step', () => {
+		beforeEach(() => {
+			// Set up a game with several moves
+			game.drop({ x: 2, y: 2, z: 0 }) // Move 0
+			game.drop({ x: 3, y: 2, z: 0 }) // Move 1
+			game.drop({ x: 2, y: 3, z: 0 }) // Move 2
+			game.drop({ x: 3, y: 3, z: 0 }) // Move 3
+		})
+
+		it('should jump to specific step in history', () => {
+			expect(game.getCurrentStep()).toBe(4)
+
+			const success = game.jumpToStep(1)
+			expect(success).toBe(true)
+			expect(game.getCurrentStep()).toBe(1)
+		})
+
+		it('should jump to initial state with index 0', () => {
+			const success = game.jumpToStep(0)
+			expect(success).toBe(true)
+			expect(game.getCurrentStep()).toBe(0)
+
+			// Board should be empty
+			const board = game.getBoard()
+			expect(board[2][2][0]).toBe(StoneType.EMPTY)
+			expect(board[3][2][0]).toBe(StoneType.EMPTY)
+
+			// Current player should be BLACK (ready to make first move)
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK)
+		})
+
+		it('should rebuild board correctly at target step', () => {
+			game.jumpToStep(2) // After 2 moves
+
+			const board = game.getBoard()
+			expect(board[2][2][0]).toBe(StoneType.BLACK)
+			expect(board[3][2][0]).toBe(StoneType.WHITE)
+			expect(board[2][3][0]).toBe(StoneType.EMPTY) // Not placed yet
+		})
+
+		it('should set correct player after jump', () => {
+			game.jumpToStep(2) // After 2 moves (black, white)
+			expect(game.getCurrentPlayer()).toBe(StoneType.BLACK)
+
+			game.jumpToStep(3) // After 3 moves
+			expect(game.getCurrentPlayer()).toBe(StoneType.WHITE)
+		})
+
+		it('should not jump to invalid index', () => {
+			const successNegative = game.jumpToStep(-5)
+			expect(successNegative).toBe(false)
+
+			const successTooLarge = game.jumpToStep(100)
+			expect(successTooLarge).toBe(false)
+		})
+
+		it('should do nothing when jumping to current step', () => {
+			const currentStep = game.getCurrentStep()
+			const success = game.jumpToStep(currentStep)
+			expect(success).toBe(false)
+			expect(game.getCurrentStep()).toBe(currentStep)
+		})
+
+		it('should allow jumping forward and backward', () => {
+			game.jumpToStep(1)
+			expect(game.getCurrentStep()).toBe(1)
+
+			game.jumpToStep(3)
+			expect(game.getCurrentStep()).toBe(3)
+
+			game.jumpToStep(0)
+			expect(game.getCurrentStep()).toBe(0)
+		})
+	})
+
+
+	describe('Complex History Scenarios', () => {
+		it('should handle undo after jump', () => {
+			game.drop({ x: 2, y: 2, z: 0 }) // Move 1
+			game.drop({ x: 3, y: 2, z: 0 }) // Move 2
+
+			game.jumpToStep(1) // Jump to to step 1 (after move 1)
+			expect(game.getCurrentStep()).toBe(1)
+
+			game.undo() // Should go back to start
+
+			expect(game.getCurrentStep()).toBe(0)
+			const board = game.getBoard()
+			expect(board[2][2][0]).toBe(StoneType.EMPTY)
+		})
+
+		it('should handle redo after jump', () => {
+			game.drop({ x: 2, y: 2, z: 0 }) // Move 1
+			game.drop({ x: 3, y: 2, z: 0 }) // Move 2
+
+			game.jumpToStep(1) // Jump to to step 1 (after move 1)
+			game.redo() // Should move forward to move 2
+
+			expect(game.getCurrentStep()).toBe(2)
+			const board = game.getBoard()
+			expect(board[3][2][0]).toBe(StoneType.WHITE)
+		})
+
+		it('should maintain history integrity across operations', () => {
+			game.drop({ x: 2, y: 2, z: 0 })
+			game.drop({ x: 3, y: 2, z: 0 })
+			game.drop({ x: 2, y: 3, z: 0 })
+
+			const originalHistory = game.getHistory()
+			expect(originalHistory.length).toBe(3)
+
+			// Jump back and forth
+			game.jumpToStep(0)
+			game.jumpToStep(2)
+			game.undo()
+			game.redo()
+
+			// History should remain unchanged
+			const finalHistory = game.getHistory()
+			expect(finalHistory.length).toBe(3)
+			expect(finalHistory).toEqual(originalHistory)
+		})
+	})
+})

trigo-web/tests/game/trigoGame.parserInit.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Test for TGN Parser Initialization and Functionality
+ */
+
+import { describe, it, expect, beforeAll } from "vitest";
+import { TrigoGame, StoneType, validateTGN } from "@inc/trigo/game";
+import { initializeParsers } from "@inc/trigo/parserInit";
+
+
+describe("TGN Parser - Full Integration (with synchronous API)", () => {
+
+	// Initialize parsers before running tests
+	beforeAll(async () => {
+		await initializeParsers();
+	});
+
+
+	describe("Parser Initialization", () => {
+
+		it("should initialize parsers successfully", async () => {
+			// If we get here without error, initialization succeeded
+			expect(true).toBe(true);
+		});
+
+	});
+
+
+	describe("Synchronous TGN Parsing", () => {
+
+		it("should validate TGN synchronously (no await)", () => {
+			const tgn = `[Board 5x5x5]
+1. 000 y00`;
+
+			// This should NOT be an async function - should work synchronously
+			const result = validateTGN(tgn);
+
+			expect(result.valid).toBe(true);
+			expect(result.error).toBeUndefined();
+		});
+
+
+		it("should detect invalid TGN synchronously", () => {
+			const tgn = `[Board invalid]`;
+
+			// Synchronous validation
+			const result = validateTGN(tgn);
+
+			expect(result.valid).toBe(false);
+			expect(result.error).toBeDefined();
+		});
+
+	});
+
+
+	describe("Synchronous Game Import (fromTGN)", () => {
+
+		it("should import TGN synchronously (no await)", () => {
+			const tgn = `[Event "Test Game"]
+[Board 5x5x5]
+[Black "Alice"]
+[White "Bob"]
+
+1. 000 y00
+2. 0y0 yy0`;
+
+			// This should NOT be an async function - should work synchronously
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(game.getShape()).toEqual({ x: 5, y: 5, z: 5 });
+			expect(game.getHistory()).toHaveLength(4);
+			expect(game.getGameStatus()).toBe("playing");
+		});
+
+
+		it("should replay moves correctly after import", () => {
+			const tgn = `[Board 5x5x5]
+1. 000 y00
+2. 0y0 yy0`;
+
+			const game = TrigoGame.fromTGN(tgn);
+			const board = game.getBoard();
+
+			expect(board[2][2][2]).toBe(StoneType.BLACK);  // 000
+			expect(board[3][2][2]).toBe(StoneType.WHITE);  // y00
+			expect(board[2][3][2]).toBe(StoneType.BLACK);  // 0y0
+			expect(board[3][3][2]).toBe(StoneType.WHITE);  // yy0
+		});
+
+	});
+
+
+	describe("Round-trip Testing", () => {
+
+		it("should export and re-import TGN without loss", () => {
+			// Create original game
+			const game1 = new TrigoGame({ x: 5, y: 5, z: 5 });
+			game1.startGame();
+			game1.drop({ x: 2, y: 2, z: 2 });
+			game1.drop({ x: 3, y: 2, z: 2 });
+			game1.drop({ x: 2, y: 3, z: 2 });
+
+			// Export to TGN
+			const tgn = game1.toTGN({
+				event: "Test",
+				black: "Alice",
+				white: "Bob"
+			});
+
+			// Re-import - using synchronous fromTGN (no await!)
+			const game2 = TrigoGame.fromTGN(tgn);
+
+			// Verify boards match
+			const board1 = game1.getBoard();
+			const board2 = game2.getBoard();
+
+			for (let x = 0; x < 5; x++) {
+				for (let y = 0; y < 5; y++) {
+					for (let z = 0; z < 5; z++) {
+						expect(board2[x][y][z]).toBe(board1[x][y][z]);
+					}
+				}
+			}
+
+			// Verify move counts match
+			expect(game2.getHistory()).toHaveLength(game1.getHistory().length);
+		});
+
+	});
+
+
+	describe("Lotus Architecture Compliance", () => {
+
+		it("should use pre-built parser from public/lib", () => {
+			// This test verifies that the parser was loaded successfully
+			// If it throws an error, the parser module was not initialized
+			const tgn = `[Board 5x5x5]`;
+			const result = validateTGN(tgn);
+			expect(result.valid).toBe(true);
+		});
+
+
+		it("should support both browser and Node.js equally", () => {
+			// The same synchronous API works in both environments
+			// Browser: imports from /lib/tgnParser.js (served by Vite)
+			// Node.js: imports from public/lib/tgnParser.js
+
+			const tgn = `[Board 5x5x5]
+1. 000 y00`;
+
+			// No environment checks needed - just use the API
+			const result = validateTGN(tgn);
+			const game = TrigoGame.fromTGN(tgn);
+
+			expect(result.valid).toBe(true);
+			expect(game.getShape()).toEqual({ x: 5, y: 5, z: 5 });
+		});
+
+	});
+
+});

trigo-web/tests/game/trigoGame.rules.test.ts

@@ -0,0 +1,356 @@
+/**
+ * TrigoGame Rules Tests
+ *
+ * Tests capture logic, Ko rule, suicide rule, and territory calculation
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { TrigoGame, StoneType } from '@inc/trigo/game'
+import type { BoardShape } from '@inc/trigo/types'
+
+
+describe('TrigoGame - Game Rules', () => {
+	let game: TrigoGame
+	const defaultShape: BoardShape = { x: 5, y: 5, z: 1 }  // 2D board (single z layer)
+
+	beforeEach(() => {
+		game = new TrigoGame(defaultShape)
+		game.startGame()
+	})
+
+
+	describe('Capture Logic', () => {
+		it('should capture a surrounded stone (2D case)', () => {
+			// Surround a white stone with black on 2D board (z=0)
+			//   B . B
+			//   B W B
+			//   . B .
+
+			game.drop({ x: 2, y: 2, z: 0 }) // Black left
+			game.drop({ x: 3, y: 2, z: 0 }) // White (target)
+			game.drop({ x: 4, y: 2, z: 0 }) // Black right
+			game.drop({ x: 0, y: 0, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 3, z: 0 }) // Black bottom
+			game.drop({ x: 0, y: 1, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 1, z: 0 }) // Black top - completes capture
+
+			// White stone at (3,2,0) should be captured
+			const board = game.getBoard()
+			expect(board[3][2][0]).toBe(StoneType.EMPTY)
+		})
+
+		it('should track captured stones in history', () => {
+			// Simple capture scenario on 2D board
+			game.drop({ x: 2, y: 2, z: 0 }) // Black left
+			game.drop({ x: 3, y: 2, z: 0 }) // White (target)
+			game.drop({ x: 4, y: 2, z: 0 }) // Black right
+			game.drop({ x: 0, y: 0, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 3, z: 0 }) // Black bottom
+			game.drop({ x: 0, y: 1, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 1, z: 0 }) // Black top - captures
+
+			const lastStep = game.getLastStep()
+			expect(lastStep).toBeDefined()
+			expect(lastStep?.capturedPositions).toBeDefined()
+			expect(lastStep?.capturedPositions?.length).toBeGreaterThan(0)
+		})
+
+		it('should update captured counts', () => {
+			// Capture one white stone on 2D board
+			game.drop({ x: 2, y: 2, z: 0 }) // Black left
+			game.drop({ x: 3, y: 2, z: 0 }) // White (target)
+			game.drop({ x: 4, y: 2, z: 0 }) // Black right
+			game.drop({ x: 0, y: 0, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 3, z: 0 }) // Black bottom
+			game.drop({ x: 0, y: 1, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 1, z: 0 }) // Black top - captures
+
+			const counts = game.getCapturedCounts()
+			expect(counts.white).toBeGreaterThan(0)
+		})
+
+		it('should not capture stones with liberties', () => {
+			// Place stones but leave an escape route
+			game.drop({ x: 2, y: 2, z: 0 }) // Black
+			game.drop({ x: 3, y: 2, z: 0 }) // White
+			game.drop({ x: 3, y: 3, z: 0 }) // Black
+			game.drop({ x: 4, y: 2, z: 0 }) // White still has liberties
+
+			const board = game.getBoard()
+			expect(board[3][2][0]).toBe(StoneType.WHITE) // Not captured
+		})
+	})
+
+
+	describe('Ko Rule (打劫)', () => {
+		// Ko Rule (from Wikipedia):
+		// "A special rule that prevents immediate repetition of position, by a short 'loop'
+		// in which a single stone is captured, and another single stone immediately taken back.
+		// The immediate recapture is forbidden, for ONE TURN only."
+		//
+		// Example Ko situation:
+		//   Initial:        After BLACK captures:    After WHITE recaptures (ILLEGAL):
+		//     . B .             . B .                     . B .
+		//     B W B      -->    B . B              -->    B W B  (same as initial!)
+		//     . W .             . W .                     . W .
+		//
+		// The Ko rule implementation checks:
+		// 1. Previous move captured exactly ONE stone
+		// 2. Current move would capture exactly ONE stone
+		// 3. Player is placing at the previously captured position
+		// → If all true, it's a Ko violation (immediate recapture forbidden)
+
+		it('should detect Ko using TGN example: bb ab ca ba aa', () => {
+			// Real Ko example in TGN notation:
+			// 1. bb ab (BLACK at (1,1), WHITE at (0,1))
+			// 2. ca ba (BLACK at (2,0), WHITE at (1,0))
+			// 3. aa (BLACK at (0,0) - captures WHITE at ba)
+			// Then WHITE playing at ba would be Ko violation
+			//
+			// Board after moves 1-2:    After move 3 (BLACK aa):
+			//   a b c                      a b c
+			// a . W B  (y=0)             a B . B  (y=0, WHITE captured)
+			// b W B .  (y=1)             b W B .  (y=1)
+
+			game.drop({ x: 1, y: 1, z: 0 }) // Move 1: BLACK bb
+			game.drop({ x: 0, y: 1, z: 0 }) // Move 1: WHITE ab
+			game.drop({ x: 2, y: 0, z: 0 }) // Move 2: BLACK ca
+			game.drop({ x: 1, y: 0, z: 0 }) // Move 2: WHITE ba
+
+			// Before capture, verify WHITE at ba (1,0) is surrounded
+			let board = game.getBoard()
+			expect(board[1][0][0]).toBe(StoneType.WHITE) // WHITE at ba
+
+			// Move 3: BLACK aa captures WHITE at ba
+			game.drop({ x: 0, y: 0, z: 0 }) // BLACK aa
+
+			// Verify capture happened
+			board = game.getBoard()
+			expect(board[1][0][0]).toBe(StoneType.EMPTY) // ba is now empty
+			expect(board[0][0][0]).toBe(StoneType.BLACK) // aa has BLACK
+
+			const lastStep = game.getLastStep()
+			expect(lastStep?.capturedPositions).toBeDefined()
+			expect(lastStep?.capturedPositions?.length).toBe(1)
+			expect(lastStep?.capturedPositions?.[0]).toEqual({ x: 1, y: 0, z: 0 })
+
+			// Now if WHITE immediately plays at ba, it would capture BLACK at aa
+			// and recreate the original position - this is Ko!
+			const result = game.isValidMove({ x: 1, y: 0, z: 0 })
+
+			expect(result.valid).toBe(false)
+			expect(result.reason).toContain('Ko')
+		})
+
+		it('should allow recapture after intervening moves (Ko resolved)', () => {
+			// Same Ko setup as above
+			game.drop({ x: 1, y: 1, z: 0 }) // BLACK bb
+			game.drop({ x: 0, y: 1, z: 0 }) // WHITE ab
+			game.drop({ x: 2, y: 0, z: 0 }) // BLACK ca
+			game.drop({ x: 1, y: 0, z: 0 }) // WHITE ba
+			game.drop({ x: 0, y: 0, z: 0 }) // BLACK aa - captures WHITE at ba
+
+			// Per Ko rule: "immediate recapture is forbidden, for ONE TURN only"
+			// WHITE must play elsewhere first (Ko threat)
+			game.drop({ x: 3, y: 3, z: 0 }) // WHITE plays elsewhere
+			game.drop({ x: 4, y: 4, z: 0 }) // BLACK responds elsewhere
+
+			// After intervening moves, Ko is resolved
+			// WHITE can now play at ba
+			const result = game.isValidMove({ x: 1, y: 0, z: 0 })
+
+			expect(result.valid).toBe(true)
+			expect(result.reason).toBeUndefined()
+		})
+
+		it('should verify Ko rule logic after single-stone capture', () => {
+			// Additional test using the simple capture pattern
+			game.drop({ x: 2, y: 2, z: 0 }) // BLACK
+			game.drop({ x: 3, y: 2, z: 0 }) // WHITE (will be captured)
+			game.drop({ x: 4, y: 2, z: 0 }) // BLACK right
+			game.drop({ x: 0, y: 0, z: 0 }) // WHITE elsewhere
+			game.drop({ x: 3, y: 3, z: 0 }) // BLACK bottom
+			game.drop({ x: 0, y: 1, z: 0 }) // WHITE elsewhere
+			game.drop({ x: 3, y: 1, z: 0 }) // BLACK top - captures WHITE at (3,2,0)
+
+			// Verify capture happened and was recorded
+			const board = game.getBoard()
+			expect(board[3][2][0]).toBe(StoneType.EMPTY)
+
+			const lastStep = game.getLastStep()
+			expect(lastStep?.capturedPositions).toBeDefined()
+			expect(lastStep?.capturedPositions?.length).toBe(1)
+			expect(lastStep?.capturedPositions?.[0]).toEqual({ x: 3, y: 2, z: 0 })
+
+			// Move validation at the captured position should run Ko checks
+			// In this specific case, WHITE playing at (3,2,0) would be suicide (not Ko)
+			// because WHITE cannot capture any BLACK stones from that position
+			const result = game.isValidMove({ x: 3, y: 2, z: 0 })
+			expect(result.valid).toBe(false)
+			// Will be 'suicide' in this case, but Ko logic is still checked first
+		})
+	})
+
+
+	describe('Suicide Rule', () => {
+		it('should prevent suicide move (placing stone with no liberties)', () => {
+			// Surround a position completely with opponent's stones on 2D board
+			game.drop({ x: 1, y: 2, z: 0 }) // Black elsewhere
+			game.drop({ x: 2, y: 2, z: 0 }) // White
+			game.drop({ x: 1, y: 3, z: 0 }) // Black elsewhere
+			game.drop({ x: 4, y: 2, z: 0 }) // White
+			game.drop({ x: 1, y: 1, z: 0 }) // Black elsewhere
+			game.drop({ x: 3, y: 3, z: 0 }) // White
+			game.drop({ x: 1, y: 0, z: 0 }) // Black elsewhere
+			game.drop({ x: 3, y: 1, z: 0 }) // White
+
+			// Position (3,2,0) is now surrounded by white stones (4 neighbors on 2D)
+			// Black trying to play there would be suicide
+			const result = game.isValidMove({ x: 3, y: 2, z: 0 })
+
+			if (result.valid === false) {
+				expect(result.reason).toContain('suicide')
+			}
+		})
+
+		it('should allow move that captures opponent (not suicide)', () => {
+			// Set up a position where placing a stone captures opponent
+			// thereby creating liberties for itself
+			game.drop({ x: 2, y: 2, z: 0 }) // Black
+			game.drop({ x: 3, y: 2, z: 0 }) // White (will be captured)
+			game.drop({ x: 4, y: 2, z: 0 }) // Black
+			game.drop({ x: 3, y: 1, z: 0 }) // White elsewhere
+			game.drop({ x: 3, y: 3, z: 0 }) // Black
+			game.drop({ x: 1, y: 1, z: 0 }) // White elsewhere
+
+			// Black placing at (2,1,0) captures white, so it's not suicide
+			const result = game.isValidMove({ x: 2, y: 1, z: 0 })
+			expect(result.valid).toBe(true)
+		})
+	})
+
+
+	describe('Territory Calculation', () => {
+		it('should calculate territory for empty board', () => {
+			const territory = game.getTerritory()
+			expect(territory).toBeDefined()
+			expect(territory.black).toBe(0)
+			expect(territory.white).toBe(0)
+			expect(territory.neutral).toBeGreaterThan(0)
+		})
+
+		it('should calculate territory with some stones', () => {
+			// Place a few stones
+			game.drop({ x: 0, y: 0, z: 0 }) // Black
+			game.drop({ x: 4, y: 4, z: 4 }) // White
+			game.drop({ x: 0, y: 0, z: 1 }) // Black
+			game.drop({ x: 4, y: 4, z: 3 }) // White
+
+			const territory = game.getTerritory()
+			expect(territory).toBeDefined()
+			// With stones placed, some territory should be claimed
+			expect(territory.black + territory.white + territory.neutral).toBeGreaterThan(0)
+		})
+
+		it('should cache territory calculation', () => {
+			const territory1 = game.getTerritory()
+			const territory2 = game.getTerritory()
+
+			// Should return same result (cached)
+			expect(territory1).toEqual(territory2)
+		})
+
+		it('should invalidate territory cache after move', () => {
+			const territory1 = game.getTerritory()
+
+			game.drop({ x: 2, y: 2, z: 2 })
+
+			const territory2 = game.getTerritory()
+
+			// Territory may have changed
+			// At minimum, it should recalculate (not use stale cache)
+			expect(territory2).toBeDefined()
+		})
+	})
+
+
+	describe('Game End Conditions', () => {
+		it('should end game and calculate winner on double pass', () => {
+			// Set up a game state
+			game.drop({ x: 0, y: 0, z: 0 }) // Black
+			game.drop({ x: 4, y: 4, z: 4 }) // White
+
+			// Double pass
+			game.pass() // Black
+			game.pass() // White
+
+			expect(game.getGameStatus()).toBe('finished')
+			const result = game.getGameResult()
+			expect(result).toBeDefined()
+			expect(result?.winner).toBeDefined()
+			expect(result?.reason).toBe('double-pass')
+			expect(result?.score).toBeDefined()
+		})
+
+		it('should declare winner based on territory', () => {
+			// Create a situation where black has more territory
+			game.drop({ x: 0, y: 0, z: 0 }) // Black
+			game.drop({ x: 0, y: 0, z: 1 }) // White
+			game.drop({ x: 1, y: 0, z: 0 }) // Black
+			game.drop({ x: 0, y: 1, z: 1 }) // White
+			game.drop({ x: 0, y: 1, z: 0 }) // Black
+			game.drop({ x: 1, y: 0, z: 1 }) // White
+			game.drop({ x: 1, y: 1, z: 0 }) // Black
+
+			game.pass()
+			game.pass()
+
+			const result = game.getGameResult()
+			expect(result?.winner).toBeDefined()
+			// Winner determined by territory + captured stones
+		})
+
+		it('should handle draw situation', () => {
+			// Empty board - should be a draw
+			game.pass()
+			game.pass()
+
+			const result = game.getGameResult()
+			expect(result).toBeDefined()
+			// In perfectly equal situation, could be draw
+		})
+	})
+
+
+	describe('Complex Scenarios', () => {
+		it('should handle multiple captures in one move', () => {
+			// This would require a specific board setup
+			// where one move captures multiple groups
+			// For now, test that the system handles it gracefully
+
+			game.drop({ x: 2, y: 2, z: 2 })
+			const counts = game.getCapturedCounts()
+			expect(counts).toBeDefined()
+		})
+
+		it('should maintain game integrity across complex moves', () => {
+			// Play a realistic game sequence
+			const moves = [
+				{ x: 2, y: 2, z: 0 },
+				{ x: 3, y: 2, z: 0 },
+				{ x: 2, y: 3, z: 0 },
+				{ x: 3, y: 3, z: 0 },
+				{ x: 1, y: 2, z: 0 },
+			]
+
+			for (const move of moves) {
+				const success = game.drop(move)
+				expect(success).toBe(true)
+			}
+
+			// Game should be in valid state
+			expect(game.getCurrentStep()).toBe(moves.length)
+			expect(game.getHistory().length).toBe(moves.length)
+		})
+	})
+})

trigo-web/tests/game/trigoGame.state.test.ts

@@ -0,0 +1,406 @@
+/**
+ * TrigoGame State Management and Persistence Tests
+ *
+ * Tests game status, serialization, and session storage
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { TrigoGame, StoneType } from '@inc/trigo/game'
+import type { BoardShape } from '@inc/trigo/types'
+
+
+describe('TrigoGame - State Management', () => {
+	let game: TrigoGame
+	const defaultShape: BoardShape = { x: 5, y: 5, z: 5 }
+
+	beforeEach(() => {
+		game = new TrigoGame(defaultShape)
+	})
+
+
+	describe('Game Status', () => {
+		it('should start with idle status', () => {
+			expect(game.getGameStatus()).toBe('idle')
+		})
+
+		it('should change to playing when started', () => {
+			game.startGame()
+			expect(game.getGameStatus()).toBe('playing')
+		})
+
+		it('should change to finished on surrender', () => {
+			game.startGame()
+			game.surrender()
+			expect(game.getGameStatus()).toBe('finished')
+		})
+
+		it('should change to finished on double pass', () => {
+			game.startGame()
+			game.pass()
+			game.pass()
+			expect(game.getGameStatus()).toBe('finished')
+		})
+
+		it('should allow manual status change', () => {
+			game.setGameStatus('paused')
+			expect(game.getGameStatus()).toBe('paused')
+		})
+
+		it('should check if game is active', () => {
+			expect(game.isGameActive()).toBe(false)
+			game.startGame()
+			expect(game.isGameActive()).toBe(true)
+			game.surrender()
+			expect(game.isGameActive()).toBe(false)
+		})
+	})
+
+
+	describe('Game Result', () => {
+		beforeEach(() => {
+			game.startGame()
+		})
+
+		it('should have no result initially', () => {
+			expect(game.getGameResult()).toBeUndefined()
+		})
+
+		it('should set result on resignation', () => {
+			game.surrender()
+			const result = game.getGameResult()
+
+			expect(result).toBeDefined()
+			expect(result?.winner).toBe('white')
+			expect(result?.reason).toBe('resignation')
+		})
+
+		it('should set result on double pass', () => {
+			game.drop({ x: 0, y: 0, z: 0 }) // Black
+			game.pass() // White
+			game.pass() // Black
+
+			const result = game.getGameResult()
+			expect(result).toBeDefined()
+			expect(result?.reason).toBe('double-pass')
+			expect(result?.score).toBeDefined()
+		})
+
+		it('should include territory score in result', () => {
+			game.pass()
+			game.pass()
+
+			const result = game.getGameResult()
+			expect(result?.score).toBeDefined()
+			expect(result?.score?.black).toBeDefined()
+			expect(result?.score?.white).toBeDefined()
+		})
+	})
+
+
+	describe('Pass Count', () => {
+		beforeEach(() => {
+			game.startGame()
+		})
+
+		it('should start with zero passes', () => {
+			expect(game.getPassCount()).toBe(0)
+		})
+
+		it('should increment on pass', () => {
+			game.pass()
+			expect(game.getPassCount()).toBe(1)
+
+			game.pass()
+			expect(game.getPassCount()).toBe(2)
+		})
+
+		it('should reset on stone placement', () => {
+			game.pass()
+			game.drop({ x: 2, y: 2, z: 2 })
+			expect(game.getPassCount()).toBe(0)
+		})
+
+		it('should maintain correct count across undo', () => {
+			game.pass()
+			expect(game.getPassCount()).toBe(1)
+
+			game.undo()
+			expect(game.getPassCount()).toBe(0)
+		})
+	})
+
+
+	describe('Callbacks', () => {
+		it('should trigger onStepAdvance callback', () => {
+			const onStepAdvance = vi.fn()
+			const gameWithCallbacks = new TrigoGame(defaultShape, { onStepAdvance })
+
+			gameWithCallbacks.startGame()
+			gameWithCallbacks.drop({ x: 2, y: 2, z: 2 })
+
+			expect(onStepAdvance).toHaveBeenCalledOnce()
+		})
+
+		it('should trigger onStepBack callback on undo', () => {
+			const onStepBack = vi.fn()
+			const gameWithCallbacks = new TrigoGame(defaultShape, { onStepBack })
+
+			gameWithCallbacks.startGame()
+			gameWithCallbacks.drop({ x: 2, y: 2, z: 2 })
+			gameWithCallbacks.undo()
+
+			expect(onStepBack).toHaveBeenCalledOnce()
+		})
+
+		it('should trigger onCapture callback', () => {
+			const onCapture = vi.fn()
+			const gameWithCallbacks = new TrigoGame(defaultShape, { onCapture })
+
+			gameWithCallbacks.startGame()
+
+			// Create capture scenario
+			gameWithCallbacks.drop({ x: 2, y: 2, z: 2 }) // Black
+			gameWithCallbacks.drop({ x: 3, y: 2, z: 2 }) // White (target)
+			gameWithCallbacks.drop({ x: 4, y: 2, z: 2 }) // Black
+			gameWithCallbacks.drop({ x: 3, y: 1, z: 2 }) // White
+			gameWithCallbacks.drop({ x: 3, y: 3, z: 2 }) // Black
+			gameWithCallbacks.drop({ x: 3, y: 1, z: 1 }) // White
+			gameWithCallbacks.drop({ x: 3, y: 2, z: 1 }) // Black
+			gameWithCallbacks.drop({ x: 3, y: 1, z: 3 }) // White
+			gameWithCallbacks.drop({ x: 3, y: 2, z: 3 }) // Black - captures
+
+			// onCapture should have been called if capture occurred
+			if (onCapture.mock.calls.length > 0) {
+				expect(onCapture).toHaveBeenCalled()
+			}
+		})
+
+		it('should trigger onWin callback on game end', () => {
+			const onWin = vi.fn()
+			const gameWithCallbacks = new TrigoGame(defaultShape, { onWin })
+
+			gameWithCallbacks.startGame()
+			gameWithCallbacks.surrender()
+
+			expect(onWin).toHaveBeenCalledOnce()
+		})
+	})
+})
+
+
+describe('TrigoGame - Serialization', () => {
+	let game: TrigoGame
+	const defaultShape: BoardShape = { x: 5, y: 5, z: 5 }
+
+	beforeEach(() => {
+		game = new TrigoGame(defaultShape)
+		game.startGame()
+	})
+
+
+	describe('JSON Serialization', () => {
+		it('should serialize game state', () => {
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.drop({ x: 3, y: 2, z: 2 })
+
+			const json = game.toJSON()
+
+			expect(json).toBeDefined()
+			expect(json).toHaveProperty('shape')
+			expect(json).toHaveProperty('currentPlayer')
+			expect(json).toHaveProperty('currentStepIndex')
+			expect(json).toHaveProperty('history')
+			expect(json).toHaveProperty('board')
+			expect(json).toHaveProperty('gameStatus')
+			expect(json).toHaveProperty('passCount')
+		})
+
+		it('should deserialize game state', () => {
+			// Set up a game state
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.drop({ x: 3, y: 2, z: 2 })
+			game.pass()
+
+			const json = game.toJSON()
+
+			// Create new game and load state
+			const newGame = new TrigoGame()
+			const success = newGame.fromJSON(json)
+
+			expect(success).toBe(true)
+			expect(newGame.getCurrentStep()).toBe(game.getCurrentStep())
+			expect(newGame.getCurrentPlayer()).toBe(game.getCurrentPlayer())
+			expect(newGame.getGameStatus()).toBe(game.getGameStatus())
+			expect(newGame.getPassCount()).toBe(game.getPassCount())
+		})
+
+		it('should preserve board state through serialization', () => {
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.drop({ x: 3, y: 2, z: 2 })
+
+			const originalBoard = game.getBoard()
+			const json = game.toJSON()
+
+			const newGame = new TrigoGame()
+			newGame.fromJSON(json)
+			const restoredBoard = newGame.getBoard()
+
+			// Check key positions
+			expect(restoredBoard[2][2][2]).toBe(originalBoard[2][2][2])
+			expect(restoredBoard[3][2][2]).toBe(originalBoard[3][2][2])
+		})
+
+		it('should preserve history through serialization', () => {
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.drop({ x: 3, y: 2, z: 2 })
+
+			const originalHistory = game.getHistory()
+			const json = game.toJSON()
+
+			const newGame = new TrigoGame()
+			newGame.fromJSON(json)
+			const restoredHistory = newGame.getHistory()
+
+			expect(restoredHistory.length).toBe(originalHistory.length)
+		})
+
+		it('should handle malformed JSON gracefully', () => {
+			const newGame = new TrigoGame()
+			const success = newGame.fromJSON({ invalid: 'data' })
+
+			// Should return false for invalid data
+			expect(success).toBe(false)
+		})
+	})
+
+
+	describe('Session Storage', () => {
+		// Mock sessionStorage for testing
+		const sessionStorageMock = (() => {
+			let store: Record<string, string> = {}
+
+			return {
+				getItem: (key: string) => store[key] || null,
+				setItem: (key: string, value: string) => { store[key] = value },
+				removeItem: (key: string) => { delete store[key] },
+				clear: () => { store = {} }
+			}
+		})()
+
+		beforeEach(() => {
+			// Set up globalThis.sessionStorage mock
+			if (typeof globalThis !== 'undefined') {
+				(globalThis as any).sessionStorage = sessionStorageMock
+				sessionStorageMock.clear()
+			}
+		})
+
+		it('should save to session storage', () => {
+			game.drop({ x: 2, y: 2, z: 2 })
+
+			const success = game.saveToSessionStorage('testKey')
+			expect(success).toBe(true)
+
+			const saved = sessionStorageMock.getItem('testKey')
+			expect(saved).toBeDefined()
+			expect(saved).not.toBeNull()
+		})
+
+		it('should load from session storage', () => {
+			// Save game state
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.drop({ x: 3, y: 2, z: 2 })
+			game.saveToSessionStorage('testKey')
+
+			// Create new game and load
+			const newGame = new TrigoGame()
+			const success = newGame.loadFromSessionStorage('testKey')
+
+			expect(success).toBe(true)
+			expect(newGame.getCurrentStep()).toBe(2)
+
+			const board = newGame.getBoard()
+			expect(board[2][2][2]).toBe(StoneType.BLACK)
+			expect(board[3][2][2]).toBe(StoneType.WHITE)
+		})
+
+		it('should clear session storage', () => {
+			game.saveToSessionStorage('testKey')
+
+			game.clearSessionStorage('testKey')
+
+			const saved = sessionStorageMock.getItem('testKey')
+			expect(saved).toBeNull()
+		})
+
+		it('should return false when loading non-existent data', () => {
+			const newGame = new TrigoGame()
+			const success = newGame.loadFromSessionStorage('nonExistentKey')
+
+			expect(success).toBe(false)
+		})
+
+		it('should use default key when not specified', () => {
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.saveToSessionStorage() // No key specified
+
+			const saved = sessionStorageMock.getItem('trigoGameState')
+			expect(saved).toBeDefined()
+		})
+	})
+})
+
+
+describe('TrigoGame - Statistics', () => {
+	let game: TrigoGame
+	const defaultShape: BoardShape = { x: 5, y: 5, z: 5 }
+
+	beforeEach(() => {
+		game = new TrigoGame(defaultShape)
+		game.startGame()
+	})
+
+
+	describe('getStats', () => {
+		it('should return initial stats', () => {
+			const stats = game.getStats()
+
+			expect(stats.totalMoves).toBe(0)
+			expect(stats.blackMoves).toBe(0)
+			expect(stats.whiteMoves).toBe(0)
+			expect(stats.capturedByBlack).toBe(0)
+			expect(stats.capturedByWhite).toBe(0)
+			expect(stats.territory).toBeDefined()
+		})
+
+		it('should count moves correctly', () => {
+			game.drop({ x: 2, y: 2, z: 2 }) // Black
+			game.drop({ x: 3, y: 2, z: 2 }) // White
+			game.drop({ x: 2, y: 3, z: 2 }) // Black
+
+			const stats = game.getStats()
+			expect(stats.totalMoves).toBe(3)
+			expect(stats.blackMoves).toBe(2)
+			expect(stats.whiteMoves).toBe(1)
+		})
+
+		it('should not count pass moves in move counts', () => {
+			game.drop({ x: 2, y: 2, z: 2 }) // Black
+			game.pass() // White
+			game.drop({ x: 2, y: 3, z: 2 }) // Black
+
+			const stats = game.getStats()
+			expect(stats.blackMoves).toBe(2)
+			expect(stats.whiteMoves).toBe(0)
+		})
+
+		it('should include territory calculation', () => {
+			game.drop({ x: 0, y: 0, z: 0 })
+
+			const stats = game.getStats()
+			expect(stats.territory.black).toBeDefined()
+			expect(stats.territory.white).toBeDefined()
+			expect(stats.territory.neutral).toBeDefined()
+		})
+	})
+})

trigo-web/tests/game/trigoGame.tgn.test.ts

@@ -0,0 +1,229 @@
+/**
+ * TrigoGame TGN Export Tests
+ *
+ * Tests the TGN (Trigo Game Notation) export functionality
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { TrigoGame, StoneType } from '@inc/trigo/game'
+import type { BoardShape } from '@inc/trigo/types'
+
+
+describe('TrigoGame - TGN Export', () => {
+	let game: TrigoGame
+	const defaultShape: BoardShape = { x: 5, y: 5, z: 5 }
+
+
+	beforeEach(() => {
+		game = new TrigoGame(defaultShape)
+		game.startGame()
+	})
+
+
+	describe('Basic TGN Export', () => {
+		it('should export empty game with board size', () => {
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('[Board 5x5x5]')
+			expect(tgn.trim()).not.toBe('')
+		})
+
+		it('should export 2D board format correctly', () => {
+			const game2d = new TrigoGame({ x: 19, y: 19, z: 1 })
+			game2d.startGame()
+			const tgn = game2d.toTGN()
+
+			expect(tgn).toContain('[Board 19x19]')
+		})
+
+		it('should export game with metadata', () => {
+			const tgn = game.toTGN({
+				event: 'World Championship',
+				site: 'Tokyo',
+				date: '2025.10.31',
+				black: 'Alice',
+				white: 'Bob'
+			})
+
+			expect(tgn).toContain('[Event "World Championship"]')
+			expect(tgn).toContain('[Site "Tokyo"]')
+			expect(tgn).toContain('[Date "2025.10.31"]')
+			expect(tgn).toContain('[Black "Alice"]')
+			expect(tgn).toContain('[White "Bob"]')
+		})
+
+		it('should include optional metadata tags', () => {
+			const tgn = game.toTGN({
+				rules: 'Chinese',
+				timeControl: '30+10',
+				application: 'Trigo v1.0'
+			})
+
+			expect(tgn).toContain('[Rules "Chinese"]')
+			expect(tgn).toContain('[TimeControl "30+10"]')
+			expect(tgn).toContain('[Application "Trigo v1.0"]')
+		})
+	})
+
+
+	describe('Move Sequence Export', () => {
+		it('should export simple move sequence', () => {
+			// Play some moves
+			game.drop({ x: 2, y: 2, z: 2 }) // Black at center - "000"
+			game.drop({ x: 3, y: 2, z: 2 }) // White - "y00"
+			game.drop({ x: 2, y: 3, z: 2 }) // Black - "0y0"
+
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('1. 000 y00')
+			expect(tgn).toContain('2. 0y0')
+		})
+
+		it('should export moves with correct coordinates', () => {
+			// Test corner positions
+			game.drop({ x: 0, y: 0, z: 0 }) // Black - "aaa"
+			game.drop({ x: 4, y: 4, z: 4 }) // White - "zzz"
+
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('1. aaa zzz')
+		})
+
+		it('should export pass moves', () => {
+			game.drop({ x: 2, y: 2, z: 2 }) // Black
+			game.pass() // White passes
+			game.drop({ x: 3, y: 2, z: 2 }) // Black
+
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('1. 000 Pass')
+			expect(tgn).toContain('2. y00')
+		})
+
+		it('should export multiple rounds correctly', () => {
+			// Play 4 moves (2 rounds)
+			game.drop({ x: 0, y: 0, z: 0 }) // 1. Black
+			game.drop({ x: 1, y: 0, z: 0 }) // 1. White
+			game.drop({ x: 0, y: 1, z: 0 }) // 2. Black
+			game.drop({ x: 1, y: 1, z: 0 }) // 2. White
+
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('1. aaa baa')
+			expect(tgn).toContain('2. aba bba')
+		})
+	})
+
+
+	describe('Game Result Export', () => {
+		it('should export resignation result', () => {
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.surrender() // White surrenders
+
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('[Result "B+Resign"]')
+		})
+
+		it('should export double pass result', () => {
+			game.drop({ x: 2, y: 2, z: 2 }) // Black
+			game.drop({ x: 3, y: 2, z: 2 }) // White
+			game.pass() // Black pass
+			game.pass() // White pass - game ends
+
+			const tgn = game.toTGN()
+
+			// Result should be present (winner determined by territory)
+			expect(tgn).toContain('[Result "')
+		})
+	})
+
+
+	describe('Complete Game Example', () => {
+		it('should export a complete game with all elements', () => {
+			const tgn = game.toTGN({
+				event: 'Test Game',
+				site: 'Local',
+				date: '2025.11.03',
+				black: 'Player 1',
+				white: 'Player 2',
+				rules: 'Chinese',
+				application: 'Trigo Test'
+			})
+
+			// Should have metadata section
+			expect(tgn).toContain('[Event "Test Game"]')
+			expect(tgn).toContain('[Site "Local"]')
+			expect(tgn).toContain('[Date "2025.11.03"]')
+			expect(tgn).toContain('[Black "Player 1"]')
+			expect(tgn).toContain('[White "Player 2"]')
+			expect(tgn).toContain('[Board 5x5x5]')
+			expect(tgn).toContain('[Rules "Chinese"]')
+			expect(tgn).toContain('[Application "Trigo Test"]')
+
+			// Should have empty line after metadata
+			const lines = tgn.split('\n')
+			const boardLineIndex = lines.findIndex(l => l.includes('[Board'))
+			const applicationLineIndex = lines.findIndex(l => l.includes('[Application'))
+			// Empty line after last metadata tag
+			expect(lines[applicationLineIndex + 1]).toBe('')
+		})
+
+		it('should format output with proper line breaks', () => {
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.drop({ x: 3, y: 2, z: 2 })
+
+			const tgn = game.toTGN()
+			const lines = tgn.split('\n')
+
+			// Should end with empty line
+			expect(lines[lines.length - 1]).toBe('')
+
+			// Should have moves on separate lines from metadata
+			const moveLines = lines.filter(l => l.match(/^\d+\./))
+			expect(moveLines.length).toBeGreaterThan(0)
+		})
+	})
+
+
+	describe('Edge Cases', () => {
+		it('should handle game with no moves', () => {
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('[Board 5x5x5]')
+			// Should not have any move numbers
+			expect(tgn).not.toMatch(/\d+\./)
+		})
+
+		it('should handle incomplete rounds', () => {
+			game.drop({ x: 2, y: 2, z: 2 }) // Only black's move
+
+			const tgn = game.toTGN()
+
+			expect(tgn).toContain('1. 000')
+			// Should not have white's move on this line
+			const lines = tgn.split('\n')
+			const moveLine = lines.find(l => l.startsWith('1.'))
+			expect(moveLine).not.toContain(' z') // No white move
+		})
+
+		it('should export TGN that can be read back', () => {
+			// Play a simple game
+			game.drop({ x: 2, y: 2, z: 2 })
+			game.drop({ x: 3, y: 2, z: 2 })
+			game.drop({ x: 2, y: 3, z: 2 })
+			game.drop({ x: 3, y: 3, z: 2 })
+
+			const tgn = game.toTGN({
+				black: 'Alice',
+				white: 'Bob'
+			})
+
+			// TGN should be valid format
+			expect(tgn).toContain('[Black "Alice"]')
+			expect(tgn).toContain('[White "Bob"]')
+			expect(tgn).toContain('1. 000 y00')
+			expect(tgn).toContain('2. 0y0 yy0')
+		})
+	})
+})

trigo-web/tests/game/verify_capture.test.ts

@@ -0,0 +1,79 @@
+import { describe, it } from 'vitest'
+import { TrigoGame, StoneType } from '@inc/trigo/game'
+
+describe('Verify Capture Logic', () => {
+	it('step by step capture verification', () => {
+		const game = new TrigoGame({ x: 5, y: 5, z: 1 })
+		game.startGame()
+
+		console.log("\n=== Step-by-step Capture Verification ===")
+		console.log("Target: White at (3, 2, 0)")
+		console.log("Need to surround with Black at:")
+		console.log("  Left:   (2, 2, 0)")
+		console.log("  Right:  (4, 2, 0)")
+		console.log("  Top:    (3, 1, 0)")
+		console.log("  Bottom: (3, 3, 0)")
+
+		// Move 1: Black left
+		game.drop({ x: 2, y: 2, z: 0 })
+		console.log("\nMove 1: Black at (2, 2, 0) - LEFT of white")
+
+		// Move 2: White target
+		game.drop({ x: 3, y: 2, z: 0 })
+		console.log("Move 2: White at (3, 2, 0) - TARGET")
+
+		// Move 3: Black right
+		game.drop({ x: 4, y: 2, z: 0 })
+		console.log("Move 3: Black at (4, 2, 0) - RIGHT of white")
+
+		// Move 4: White elsewhere
+		game.drop({ x: 0, y: 0, z: 0 })
+		console.log("Move 4: White at (0, 0, 0) - elsewhere")
+
+		// Move 5: Black bottom
+		game.drop({ x: 3, y: 3, z: 0 })
+		console.log("Move 5: Black at (3, 3, 0) - BOTTOM of white")
+
+		// Move 6: White elsewhere
+		game.drop({ x: 0, y: 1, z: 0 })
+		console.log("Move 6: White at (0, 1, 0) - elsewhere")
+
+		console.log("\nBefore final move - White's neighbors:")
+		const board = game.getBoard()
+		console.log(`  Left   (2, 2, 0): ${board[2][2][0]} (${board[2][2][0] === StoneType.BLACK ? 'BLACK' : 'other'})`)
+		console.log(`  Right  (4, 2, 0): ${board[4][2][0]} (${board[4][2][0] === StoneType.BLACK ? 'BLACK' : 'other'})`)
+		console.log(`  Top    (3, 1, 0): ${board[3][1][0]} (${board[3][1][0] === StoneType.EMPTY ? 'EMPTY' : 'occupied'})`)
+		console.log(`  Bottom (3, 3, 0): ${board[3][3][0]} (${board[3][3][0] === StoneType.BLACK ? 'BLACK' : 'other'})`)
+		console.log(`  Target (3, 2, 0): ${board[3][2][0]} (WHITE=${StoneType.WHITE})`)
+
+		// Move 7: Black top - should capture
+		console.log("\nMove 7: Black at (3, 1, 0) - TOP of white (should capture)")
+		game.drop({ x: 3, y: 1, z: 0 })
+
+		console.log("\n=== After final move ===")
+		const finalBoard = game.getBoard()
+		console.log(`Target (3, 2, 0): ${finalBoard[3][2][0]} (should be 0=EMPTY if captured)`)
+		console.log(`Neighbors after capture:`)
+		console.log(`  Left   (2, 2, 0): ${finalBoard[2][2][0]}`)
+		console.log(`  Right  (4, 2, 0): ${finalBoard[4][2][0]}`)
+		console.log(`  Top    (3, 1, 0): ${finalBoard[3][1][0]}`)
+		console.log(`  Bottom (3, 3, 0): ${finalBoard[3][3][0]}`)
+
+		const lastStep = game.getLastStep()
+		console.log(`\nCapture info:`)
+		console.log(`  capturedPositions: ${JSON.stringify(lastStep?.capturedPositions)}`)
+		console.log(`  captured count: ${game.getCapturedCounts().white}`)
+
+		// Verification
+		if (finalBoard[3][2][0] === StoneType.EMPTY) {
+			console.log("\n✅ SUCCESS: White was captured!")
+		} else {
+			console.log("\n❌ FAILED: White was NOT captured")
+			console.log("All neighbors should be BLACK:")
+			console.log(`  Left:   ${finalBoard[2][2][0] === StoneType.BLACK ? '✅' : '❌'}`)
+			console.log(`  Right:  ${finalBoard[4][2][0] === StoneType.BLACK ? '✅' : '❌'}`)
+			console.log(`  Top:    ${finalBoard[3][1][0] === StoneType.BLACK ? '✅' : '❌'}`)
+			console.log(`  Bottom: ${finalBoard[3][3][0] === StoneType.BLACK ? '✅' : '❌'}`)
+		}
+	})
+})

trigo-web/tests/mctsTerminalPropagation.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Unit Tests for MCTS Terminal State Propagation
+ *
+ * Tests the minimax propagation logic where nodes with all terminal children
+ * are themselves marked as terminal.
+ *
+ * Based on GPT-5.1 review recommendations.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { TrigoGame } from "../inc/trigo/game.js";
+import { MCTSAgent } from "../inc/mctsAgent.js";
+import { TrigoTreeAgent } from "../inc/trigoTreeAgent.js";
+import { TrigoEvaluationAgent } from "../inc/trigoEvaluationAgent.js";
+import { ModelInferencer } from "../inc/modelInferencer.js";
+import type { Move } from "../inc/trigo/types.js";
+
+
+/**
+ * Mock Tree Agent that returns uniform priors
+ */
+class MockTreeAgent extends TrigoTreeAgent {
+	constructor() {
+		super(null as any);
+	}
+
+	async scoreMoves(game: TrigoGame, moves: Move[]): Promise<Array<{ move: Move; score: number }>> {
+		// Return uniform log probabilities
+		const logProb = Math.log(1.0 / moves.length);
+		return moves.map(move => ({ move, score: logProb }));
+	}
+}
+
+
+/**
+ * Mock Evaluation Agent that returns fixed values
+ */
+class MockEvaluationAgent extends TrigoEvaluationAgent {
+	private mockValue: number;
+
+	constructor(value: number = 0.0) {
+		super(null as any);
+		this.mockValue = value;
+	}
+
+	setMockValue(value: number): void {
+		this.mockValue = value;
+	}
+
+	async evaluatePosition(game: TrigoGame): Promise<{ value: number; interpretation: string }> {
+		return {
+			value: this.mockValue,
+			interpretation: this.mockValue > 0 ? "White advantage" : "Black advantage"
+		};
+	}
+}
+
+
+/**
+ * Helper to access private MCTSNode properties via type assertion
+ */
+interface MCTSNode {
+	state: TrigoGame | null;
+	parent: MCTSNode | null;
+	action: Move | null;
+	N: Map<string, number>;
+	W: Map<string, number>;
+	Q: Map<string, number>;
+	P: Map<string, number>;
+	children: Map<string, MCTSNode>;
+	expanded: boolean;
+	terminalValue: number | null;
+	depth: number;
+	playerToMove: number;
+}
+
+
+describe("MCTS Terminal Propagation", () => {
+	let game: TrigoGame;
+	let treeAgent: MockTreeAgent;
+	let evalAgent: MockEvaluationAgent;
+	let mctsAgent: MCTSAgent;
+
+	beforeEach(() => {
+		treeAgent = new MockTreeAgent();
+		evalAgent = new MockEvaluationAgent(0.0);
+		mctsAgent = new MCTSAgent(treeAgent, evalAgent, {
+			numSimulations: 10,
+			cPuct: 1.0,
+			temperature: 1.0,
+			dirichletAlpha: 0.03,
+			dirichletEpsilon: 0.0  // Disable Dirichlet noise for testing
+		});
+	});
+
+
+	describe("Test 1: Single-Step Endgame", () => {
+		it("should propagate terminal value when Black chooses between terminal children", async () => {
+			// Setup: 5x1x1 board with 2 empty positions (a and b)
+			// Black to move, can play at position 0 (index 2) or position 1 (index 1)
+			game = new TrigoGame({ x: 5, y: 1, z: 1 });
+			game.startGame();
+
+			// Simulate near-terminal game: Black at z(4), y(3); White at a(0), b(1)
+			// Remaining: position 2 (center '0')
+			game.drop({ x: 4, y: 0, z: 0 });  // Black at z
+			game.drop({ x: 0, y: 0, z: 0 });  // White at a
+			game.drop({ x: 3, y: 0, z: 0 });  // Black at y
+			game.drop({ x: 1, y: 0, z: 0 });  // White at b
+
+			// Now Black to move at position 2 (center)
+			// This will end the game
+			const result = await mctsAgent.selectMove(game, 5);
+
+			// Verify move was selected
+			expect(result.move).toBeDefined();
+
+			// Check that terminal propagation happened
+			// (Terminal value should be set on nodes)
+			expect(result.rootValue).toBeDefined();
+		});
+	});
+
+
+	describe("Test 2: Two-Step Propagation", () => {
+		it("should propagate terminal values up two levels", async () => {
+			// Setup: Near-terminal position
+			game = new TrigoGame({ x: 3, y: 1, z: 1 });
+			game.startGame();
+
+			// Black at position 0, White at position 2
+			// Remaining: position 1
+			game.drop({ x: 0, y: 0, z: 0 });  // Black
+			game.drop({ x: 2, y: 0, z: 0 });  // White
+
+			// Now Black to move - only one move possible
+			const result = await mctsAgent.selectMove(game, 3);
+
+			// After enough simulations, should mark nodes as terminal
+			expect(result.move).toBeDefined();
+		});
+	});
+
+
+	describe("Test 3: White vs Black Turn Correctness", () => {
+		it("should use max for White's turn and min for Black's turn", async () => {
+			// This is a conceptual test - we verify via the implementation
+			// White should maximize Q-values (white-positive)
+			// Black should minimize Q-values (white-positive)
+
+			// Setup simple 3x1x1 board
+			game = new TrigoGame({ x: 3, y: 1, z: 1 });
+			game.startGame();
+
+			// Run a few simulations
+			const result = await mctsAgent.selectMove(game, 1);
+
+			// Verify basic functionality works
+			expect(result.move).toBeDefined();
+			expect(result.visitCounts.size).toBeGreaterThan(0);
+		});
+	});
+
+
+	describe("Test 4: Terminal Leaf with No Actions", () => {
+		it("should handle terminal nodes with empty action sets", async () => {
+			// Create a finished game
+			game = new TrigoGame({ x: 3, y: 1, z: 1 });
+			game.startGame();
+
+			// Fill the board completely
+			game.drop({ x: 0, y: 0, z: 0 });  // Black
+			game.drop({ x: 1, y: 0, z: 0 });  // White
+			game.drop({ x: 2, y: 0, z: 0 });  // Black
+
+			// Game is now terminal (no more moves)
+			// Double-pass to finish
+			game.pass();
+			game.pass();
+
+			// Should return immediately without error
+			const result = await mctsAgent.selectMove(game, 4);
+
+			expect(result.move.isPass).toBe(true);
+			expect(result.rootValue).toBeDefined();
+		});
+	});
+
+
+	describe("Test 5: Selection Skips Terminal Nodes", () => {
+		it("should not expand terminal nodes during selection", async () => {
+			// Setup near-terminal position
+			game = new TrigoGame({ x: 5, y: 1, z: 1 });
+			game.startGame();
+
+			// Play several moves to approach terminal state
+			game.drop({ x: 0, y: 0, z: 0 });  // Black at a
+			game.drop({ x: 4, y: 0, z: 0 });  // White at z
+			game.drop({ x: 1, y: 0, z: 0 });  // Black at b
+			game.drop({ x: 3, y: 0, z: 0 });  // White at y
+
+			// One position left (center)
+			const result = await mctsAgent.selectMove(game, 5);
+
+			expect(result.move).toBeDefined();
+
+			// Should have visit counts for available moves
+			expect(result.visitCounts.size).toBeGreaterThan(0);
+		});
+	});
+
+
+	describe("Test 6: White-Positive Minimax Verification", () => {
+		it("should correctly apply minimax with white-positive values", async () => {
+			// Test scenario from verification doc:
+			// White to move with children [+5, +1, -2] should choose +5
+			// Black to move with children [+5, +1, -2] should choose -2
+
+			game = new TrigoGame({ x: 3, y: 1, z: 1 });
+			game.startGame();
+
+			// Run MCTS
+			const result = await mctsAgent.selectMove(game, 1);
+
+			// Basic verification
+			expect(result.move).toBeDefined();
+			expect(result.rootValue).toBeDefined();
+		});
+	});
+
+
+	describe("Test 7: 5x1x1 Board Complete Game", () => {
+		it("should handle 5x1x1 board terminal propagation correctly", async () => {
+			// Test terminal propagation on a 5x1x1 board
+			// Focus on verifying the mechanics work, not exact game outcome
+
+			game = new TrigoGame({ x: 5, y: 1, z: 1 });
+			game.startGame();
+
+			// Play a few moves
+			game.drop({ x: 2, y: 0, z: 0 });  // Black center
+			game.drop({ x: 0, y: 0, z: 0 });  // White a
+			game.drop({ x: 4, y: 0, z: 0 });  // Black z
+
+			// Now run MCTS to find best move for White
+			// Should handle near-terminal position correctly
+			const result = await mctsAgent.selectMove(game, 4);
+
+			expect(result.move).toBeDefined();
+			expect(result.visitCounts.size).toBeGreaterThan(0);
+			expect(result.rootValue).toBeDefined();
+
+			// The key test: terminal propagation should work without errors
+			// Even if we don't have terminal nodes yet, the mechanism should be ready
+		});
+	});
+});

trigo-web/tests/testMCTSSingleStep.ts

@@ -0,0 +1,159 @@
+/**
+ * Test MCTS consistency between TypeScript and C++
+ *
+ * Compare policy priors, visits, and Q-values
+ * on empty 5x5 board for comparison with C++ implementation
+ */
+
+import { TrigoTreeAgent } from "../inc/trigoTreeAgent.js";
+import { TrigoEvaluationAgent } from "../inc/trigoEvaluationAgent.js";
+import { TrigoGame } from "../inc/trigo/game.js";
+import { Stone } from "../inc/trigo/types.js";
+import { encodeAb0yz } from "../inc/trigo/ab0yz.js";
+import { ModelInferencer } from "../inc/modelInferencer.js";
+import * as ort from "onnxruntime-node";
+
+
+async function testMCTSSingleStep() {
+	console.log("============================================================================");
+	console.log("MCTS Single Step Consistency Test (TypeScript)");
+	console.log("============================================================================");
+	console.log();
+
+	// Load models - use tree/evaluation model pair
+	const modelDir = "/home/camus/work/trigo/trigo-web/public/onnx/20251204-trigo-value-gpt2-l6-h64-251125-lr500";
+	const treeModelPath = `${modelDir}/GPT2CausalLM_ep0019_tree.onnx`;
+	const evalModelPath = `${modelDir}/GPT2CausalLM_ep0019_evaluation.onnx`;
+
+	console.log("Loading models...");
+	console.log(`  Tree model: ${treeModelPath}`);
+	console.log(`  Eval model: ${evalModelPath}`);
+	console.log();
+
+	// Create ONNX sessions
+	const sessionOptions: ort.InferenceSession.SessionOptions = {
+		executionProviders: ["cpu"]
+	};
+
+	const treeSession = await ort.InferenceSession.create(treeModelPath, sessionOptions);
+	const evalSession = await ort.InferenceSession.create(evalModelPath, sessionOptions);
+
+	// Create inferencers with proper initialization
+	const treeInferencer = new ModelInferencer(ort.Tensor as any, {
+		vocabSize: 128,
+		seqLen: 256
+	});
+	treeInferencer.setSession(treeSession as any);
+
+	const evalInferencer = new ModelInferencer(ort.Tensor as any, {
+		vocabSize: 128,
+		seqLen: 256
+	});
+	evalInferencer.setSession(evalSession as any);
+
+	console.log("[ModelInferencer] ✓ Session set successfully");
+	console.log();
+
+	// Create agents
+	const treeAgent = new TrigoTreeAgent(treeInferencer);
+	const evaluationAgent = new TrigoEvaluationAgent(evalInferencer);
+
+	// Setup game: 5x5 board, empty
+	const shape = { x: 5, y: 5, z: 1 };
+	const game = new TrigoGame(shape);
+	game.startGame();
+
+	console.log("Game Configuration:");
+	console.log("  Board: 5×5×1");
+	console.log("  Position: Empty board (Move 1)");
+	console.log(`  Current player: ${game.getCurrentPlayer() === Stone.Black ? "Black" : "White"}`);
+	const validMoves = game.validMovePositions(game.getCurrentPlayer());
+	console.log(`  Valid moves: ${validMoves.length}`);
+	console.log();
+
+	// Step 1: Get policy priors directly from tree agent
+	console.log("Step 1: Getting policy priors from tree agent...");
+	const currentPlayer = game.getCurrentPlayer() === Stone.Black ? "black" : "white";
+	const moves = validMoves.map(pos => ({
+		x: pos.x,
+		y: pos.y,
+		z: pos.z,
+		player: currentPlayer as "black" | "white"
+	}));
+	moves.push({ player: currentPlayer as "black" | "white", isPass: true });
+
+	const scoredMoves = await treeAgent.scoreMoves(game, moves);
+
+	// Sort by score descending
+	scoredMoves.sort((a, b) => b.score - a.score);
+
+	// Compute priors via exp-normalize
+	const maxScore = Math.max(...scoredMoves.map(m => m.score));
+	const expScores = scoredMoves.map(m => Math.exp(m.score - maxScore));
+	const sumExp = expScores.reduce((sum, exp) => sum + exp, 0);
+
+	console.log();
+	console.log("Top 5 moves by policy prior (log score):");
+	console.log("| Rank | Move | Position | Log Score | Prior |");
+	console.log("|------|------|----------|-----------|-------|");
+
+	for (let i = 0; i < Math.min(5, scoredMoves.length); i++) {
+		const m = scoredMoves[i];
+		let moveStr: string;
+		let posStr: string;
+
+		if (m.move.isPass) {
+			moveStr = "Pass";
+			posStr = "N/A";
+		} else {
+			moveStr = encodeAb0yz([m.move.x!, m.move.y!, m.move.z!], [shape.x, shape.y, shape.z]);
+			posStr = `(${m.move.x},${m.move.y},${m.move.z})`;
+		}
+
+		const prior = expScores[i] / sumExp;
+		console.log(`| ${i + 1} | ${moveStr} | ${posStr} | ${m.score.toFixed(6)} | ${prior.toFixed(6)} |`);
+	}
+	console.log();
+
+	// Step 2: Get value estimate directly
+	console.log("Step 2: Getting value estimate...");
+	const evaluation = await evaluationAgent.evaluatePosition(game);
+	console.log(`  Value: ${evaluation.value.toFixed(6)} (${evaluation.interpretation})`);
+	console.log();
+
+	// Summary for comparison
+	console.log("============================================================================");
+	console.log("Summary for C++ Comparison:");
+	console.log("============================================================================");
+	console.log();
+	console.log("Policy Priors (top 5):");
+	for (let i = 0; i < Math.min(5, scoredMoves.length); i++) {
+		const m = scoredMoves[i];
+		let moveStr: string;
+
+		if (m.move.isPass) {
+			moveStr = "Pass";
+		} else {
+			moveStr = encodeAb0yz([m.move.x!, m.move.y!, m.move.z!], [shape.x, shape.y, shape.z]);
+		}
+
+		const prior = expScores[i] / sumExp;
+		console.log(`  ${i + 1}. ${moveStr} log_score=${m.score.toFixed(6)} prior=${prior.toFixed(6)}`);
+	}
+	console.log();
+	console.log(`Value estimate: ${evaluation.value.toFixed(6)}`);
+	console.log();
+
+	console.log("Expected C++ results (from test_mcts_single_step):");
+	console.log("  1. az log_score=-2.855756 prior=0.170112");
+	console.log("  2. aa log_score=-2.880302 prior=0.165987");
+	console.log("  3. yz log_score=-3.696474 prior=0.073386");
+	console.log("  4. ya log_score=-3.754188 prior=0.069271");
+	console.log("  5. bz log_score=-3.799809 prior=0.066182");
+	console.log();
+	console.log("Note: C++ uses prefix-cached model, TypeScript uses tree/evaluation models");
+	console.log("      Different models may produce different policy distributions.");
+}
+
+
+testMCTSSingleStep().catch(console.error);

trigo-web/tests/testMCTSWithVisits.ts

@@ -0,0 +1,212 @@
+/**
+ * Test MCTS with visits and Q-values - TypeScript vs C++
+ *
+ * Run actual MCTS simulations and compare:
+ * - Policy priors
+ * - Visit counts
+ * - Q-values
+ */
+
+import { MCTSAgent } from "../inc/mctsAgent.js";
+import { TrigoTreeAgent } from "../inc/trigoTreeAgent.js";
+import { TrigoEvaluationAgent } from "../inc/trigoEvaluationAgent.js";
+import { TrigoGame } from "../inc/trigo/game.js";
+import { Stone } from "../inc/trigo/types.js";
+import { encodeAb0yz } from "../inc/trigo/ab0yz.js";
+import { ModelInferencer } from "../inc/modelInferencer.js";
+import * as ort from "onnxruntime-node";
+
+
+async function testMCTSWithVisits() {
+	console.log("============================================================================");
+	console.log("MCTS with Visits and Q-values Test (TypeScript)");
+	console.log("============================================================================");
+	console.log();
+
+	// Load models
+	const modelDir = "/home/camus/work/trigo/trigo-web/public/onnx/20251204-trigo-value-gpt2-l6-h64-251125-lr500";
+	const treeModelPath = `${modelDir}/GPT2CausalLM_ep0019_tree.onnx`;
+	const evalModelPath = `${modelDir}/GPT2CausalLM_ep0019_evaluation.onnx`;
+
+	console.log("Loading models...");
+
+	const sessionOptions: ort.InferenceSession.SessionOptions = {
+		executionProviders: ["cpu"]
+	};
+
+	const treeSession = await ort.InferenceSession.create(treeModelPath, sessionOptions);
+	const evalSession = await ort.InferenceSession.create(evalModelPath, sessionOptions);
+
+	const treeInferencer = new ModelInferencer(ort.Tensor as any, {
+		vocabSize: 128,
+		seqLen: 256
+	});
+	treeInferencer.setSession(treeSession as any);
+
+	const evalInferencer = new ModelInferencer(ort.Tensor as any, {
+		vocabSize: 128,
+		seqLen: 256
+	});
+	evalInferencer.setSession(evalSession as any);
+
+	console.log("✓ Models loaded");
+	console.log();
+
+	const treeAgent = new TrigoTreeAgent(treeInferencer);
+	const evaluationAgent = new TrigoEvaluationAgent(evalInferencer);
+
+	// Setup game
+	const shape = { x: 5, y: 5, z: 1 };
+	const game = new TrigoGame(shape);
+	game.startGame();
+
+	console.log("Game Configuration:");
+	console.log(`  Board: ${shape.x}×${shape.y}×${shape.z}`);
+	console.log(`  Current player: ${game.getCurrentPlayer() === Stone.Black ? "Black" : "White"}`);
+	console.log(`  Valid moves: ${game.validMovePositions(game.getCurrentPlayer()).length}`);
+	console.log();
+
+	// MCTS configuration - match C++ settings
+	const numSimulations = 10;  // Use 10 simulations to get meaningful visits
+	console.log("MCTS Configuration:");
+	console.log(`  Simulations: ${numSimulations}`);
+	console.log("  c_puct: 1.0");
+	console.log("  Temperature: 0.01 (near-greedy)");
+	console.log("  Dirichlet noise: DISABLED (epsilon=0)");
+	console.log();
+
+	// Create MCTS agent with NO Dirichlet noise for reproducibility
+	const mctsAgent = new MCTSAgent(treeAgent, evaluationAgent, {
+		numSimulations: numSimulations,
+		cPuct: 1.0,
+		temperature: 0.01,
+		dirichletAlpha: 0.03,
+		dirichletEpsilon: 0.0  // NO noise
+	});
+
+	console.log("Running MCTS search...");
+	console.log("------------------------------------------------------------");
+
+	const startTime = Date.now();
+	const result = await mctsAgent.selectMove(game, 0);
+	const elapsedTime = Date.now() - startTime;
+
+	console.log("------------------------------------------------------------");
+	console.log();
+
+	// We need to access the internal node to get Q-values
+	// Since MCTSAgent doesn't expose them directly, we'll run scoreMoves separately
+	// to get policy priors, then show what MCTS selected
+
+	// Get policy priors separately
+	const currentPlayer = game.getCurrentPlayer() === Stone.Black ? "black" : "white";
+	const validPositions = game.validMovePositions(game.getCurrentPlayer());
+	const moves = validPositions.map(pos => ({
+		x: pos.x,
+		y: pos.y,
+		z: pos.z,
+		player: currentPlayer as "black" | "white"
+	}));
+	moves.push({ player: currentPlayer as "black" | "white", isPass: true });
+
+	const scoredMoves = await treeAgent.scoreMoves(game, moves);
+	scoredMoves.sort((a, b) => b.score - a.score);
+
+	// Compute priors
+	const maxScore = Math.max(...scoredMoves.map(m => m.score));
+	const expScores = scoredMoves.map(m => Math.exp(m.score - maxScore));
+	const sumExp = expScores.reduce((sum, exp) => sum + exp, 0);
+
+	// Build a map from action key to prior
+	const priorMap = new Map<string, number>();
+	for (let i = 0; i < scoredMoves.length; i++) {
+		const m = scoredMoves[i];
+		const actionKey = m.move.isPass ? "pass" : `${m.move.x},${m.move.y},${m.move.z}`;
+		priorMap.set(actionKey, expScores[i] / sumExp);
+	}
+
+	// Collect results with visits
+	const results: Array<{
+		move: string;
+		position: string;
+		visits: number;
+		prior: number;
+	}> = [];
+
+	for (const [actionKey, visits] of result.visitCounts.entries()) {
+		let moveNotation: string;
+		let posStr: string;
+
+		if (actionKey === "pass") {
+			moveNotation = "Pass";
+			posStr = "N/A";
+		} else {
+			const [x, y, z] = actionKey.split(",").map(Number);
+			moveNotation = encodeAb0yz([x, y, z], [shape.x, shape.y, shape.z]);
+			posStr = `(${x},${y},${z})`;
+		}
+
+		const prior = priorMap.get(actionKey) ?? 0;
+
+		results.push({
+			move: moveNotation,
+			position: posStr,
+			visits: visits,
+			prior: prior
+		});
+	}
+
+	// Sort by visits descending, then by prior
+	results.sort((a, b) => {
+		if (b.visits !== a.visits) return b.visits - a.visits;
+		return b.prior - a.prior;
+	});
+
+	// Print results
+	console.log("MCTS Results (sorted by visits):");
+	console.log("| Rank | Move | Position | Visits | Prior | Notes |");
+	console.log("|------|------|----------|--------|-------|-------|");
+
+	for (let i = 0; i < Math.min(10, results.length); i++) {
+		const r = results[i];
+		const marker = r.visits > 0 ? "Explored" : "";
+		console.log(`| ${i + 1} | ${r.move} | ${r.position} | ${r.visits} | ${r.prior.toFixed(6)} | ${marker} |`);
+	}
+	console.log();
+
+	// Print selected move
+	console.log("Selected Move:");
+	if (result.move.isPass) {
+		console.log("  Move: Pass");
+	} else {
+		const notation = encodeAb0yz([result.move.x!, result.move.y!, result.move.z!], [shape.x, shape.y, shape.z]);
+		console.log(`  Move: ${notation} (${result.move.x},${result.move.y},${result.move.z})`);
+	}
+	console.log(`  Root value: ${result.rootValue.toFixed(6)}`);
+	console.log();
+
+	// Summary statistics
+	let totalVisits = 0;
+	let exploredMoves = 0;
+	for (const [_, visits] of result.visitCounts.entries()) {
+		totalVisits += visits;
+		if (visits > 0) exploredMoves++;
+	}
+
+	console.log("Statistics:");
+	console.log(`  Total visits: ${totalVisits}`);
+	console.log(`  Explored moves: ${exploredMoves} / ${result.visitCounts.size}`);
+	console.log(`  Elapsed time: ${elapsedTime}ms`);
+	console.log();
+
+	console.log("============================================================================");
+	console.log("C++ Comparison (from test_mcts_single_step with 1 simulation):");
+	console.log("  Selected: ya (3,0,0)");
+	console.log("  Visits: 1");
+	console.log("  Q-value: -0.082214");
+	console.log("  Prior: 0.069271");
+	console.log("============================================================================");
+}
+
+
+testMCTSWithVisits().catch(console.error);

trigo-web/tests/tgn/19x19.tgn

@@ -0,0 +1,6 @@
+
+[Board 19x19]
+
+1. dd wx
+2. dw wd
+3. xv

trigo-web/tests/tgn/meta.tgn

@@ -0,0 +1,11 @@
+
+[Event "World 3D Go Championship 2025"]
+[Site "Tokyo, Japan"]
+[Date "2025.10.31"]
+[Black "Alice Chen"]
+[White "Bob Smith"]
+[Result B+ 5stones]
+[Board 5x5x5]
+[Rules "Chinese"]
+[TimeControl "30+10"]
+[Application "Trigo v1.0"]