Please address the comments from this code review:

## Overall Comments
- In `skillCoreCandidate` you call `normalizePunctuation` before searching for separators `"·"`/`"・"`, but `normalizePunctuation` already replaces those with spaces, so the separator-based split will never trigger; consider reordering or adjusting normalization to preserve the separator until after the split.
- The new locale-specific normalization helpers (e.g. `normalizeStopwordsForLocale`, `normalizeSimilarIfLocale`) repeatedly call `NormalizeInputLocale`; you could normalize the locale once per code path and pass the canonical value through to avoid redundant work and make the call sites clearer.

## Individual Comments

### Comment 1
<location path="agent/go-service/essencefilter/matchapi/util.go" line_range="148-151" />
<code_context>
 	return utf8.RuneCountInString(s)
 }

+// skillCoreCandidate strips game UI suffix after a separator (e.g. rank/size) for matching.
+func skillCoreCandidate(display string, locale string) string {
+	display = strings.TrimSpace(normalizePunctuation(display))
+	for _, sep := range []string{"·", "・"} {
+		if idx := strings.Index(display, sep); idx >= 0 {
+			return strings.TrimSpace(display[:idx])
</code_context>
<issue_to_address>
**issue (bug_risk):** normalizePunctuation removes the separators before skillCoreCandidate searches for them, breaking the intended splitting behavior.

`normalizePunctuation(display)` replaces both `"·"` and `"・"` with spaces, but you then look for those same separators to trim UI suffixes:

```go
display = strings.TrimSpace(normalizePunctuation(display))
for _, sep := range []string{"·", "・"} {
    if idx := strings.Index(display, sep); idx >= 0 {
        return strings.TrimSpace(display[:idx])
    }
}
```
Since the separators are gone, this logic never runs and trimming at `"·"`/`"・"` is effectively disabled, changing behavior from the previous implementation.

Consider either splitting on these separators before calling `normalizePunctuation`, or updating `normalizePunctuation` to preserve them and relying on this explicit splitting instead.
</issue_to_address>

### Comment 2
<location path="agent/go-service/essencefilter/matchapi/matchapi_test.go" line_range="30-39" />
<code_context>
+func TestMatchOCR_EN_ExactMatch(t *testing.T) {
</code_context>
<issue_to_address>
**suggestion:** Reuse `newEngineForTestLocale` in `TestMatchOCR_EN_ExactMatch` to avoid duplicated setup logic

This test still duplicates the `FindDefaultDataDir` + `NewEngineFromDirWithLocale` logic. Please use `engine := newEngineForTestLocale(t, LocaleEN)` so engine setup stays DRY and future changes to engine construction apply consistently across tests.
</issue_to_address>

### Comment 3
<location path="agent/go-service/essencefilter/matchapi/matchapi_test.go" line_range="427" />
<code_context>
+		{
+			name:   "EN with noisy suffix",
+			locale: LocaleEN,
</code_context>
<issue_to_address>
**suggestion (testing):** Extend multilingual fuzzy test to also assert the engine locale or localized reason, not only `MatchExact` kind

Since this test already covers multilingual suffix handling, it would be useful to also validate locale wiring. In addition to `res.Kind == MatchExact`, please assert either `engine.Locale() == tt.locale` or that `res.Reason` starts with the expected localized prefix per locale. That would surface cases where the engine is created with the wrong locale or where reason generation ignores the engine’s locale.
</issue_to_address>

### Comment 4
<location path="agent/go-service/essencefilter/matchapi/matchapi_test.go" line_range="404" />
<code_context>
 	})
 }
+
+func TestNormalizeInputForMatch_ENAliases(t *testing.T) {
+	got := NormalizeInputForMatch("heat dmg boos", LocaleEN)
+	want := "heat damage boost"
</code_context>
<issue_to_address>
**suggestion (testing):** Add normalization tests for JP/KR/CN/TC and punctuation to cover more `NormalizeInputForMatch` branches

This only exercises the EN alias path. Since `NormalizeInputForMatch` now has distinct logic for Han (CN/TC), JP, KR, and punctuation, please add tests that:
- confirm CN/TC input strips non-Han characters;
- verify JP/KR keep the expected script ranges (Hiragana/Katakana/Hangul) and drop others;
- check that full-width punctuation/separators (e.g., `：`, `・`, `·`, `/`) are normalized consistently.
This will cover the new branches in `normalizeForMatch*` and `normalizePunctuation` and better protect against regressions.

Suggested implementation:

```golang
func TestNormalizeInputForMatch_ENAliases(t *testing.T) {
	got := NormalizeInputForMatch("heat dmg boos", LocaleEN)
	want := "heat damage boost"
	if got != want {
		t.Fatalf("NormalizeInputForMatch EN mismatch, got %q want %q", got, want)
	}
}

func TestNormalizeInputForMatch_CnTcStripsNonHan(t *testing.T) {
	t.Run("CN strips non-Han", func(t *testing.T) {
		got := NormalizeInputForMatch("abc 火焰 123 ダメージ boost 攻击!!", LocaleCN)
		want := "火焰 攻击"
		if got != want {
			t.Fatalf("NormalizeInputForMatch CN Han filtering mismatch, got %q want %q", got, want)
		}
	})

	t.Run("TC strips non-Han", func(t *testing.T) {
		got := NormalizeInputForMatch("test 火焰 123 ダメージ 攻擊!!", LocaleTC)
		want := "火焰 攻擊"
		if got != want {
			t.Fatalf("NormalizeInputForMatch TC Han filtering mismatch, got %q want %q", got, want)
		}
	})
}

func TestNormalizeInputForMatch_JpKeepsJapaneseScripts(t *testing.T) {
	// Expect Hiragana, Katakana, and Kanji (Han) to be preserved while Latin/punctuation are removed or normalized.
	got := NormalizeInputForMatch("ひらがな カタカナ 漢字 ABC123!", LocaleJP)
	// Depending on the implementation, spaces between script runs may be normalized;
	// this expectation assumes they are preserved as single spaces.
	want := "ひらがな カタカナ 漢字"
	if got != want {
		t.Fatalf("NormalizeInputForMatch JP script filtering mismatch, got %q want %q", got, want)
	}
}

func TestNormalizeInputForMatch_KrKeepsHangul(t *testing.T) {
	got := NormalizeInputForMatch("한글 Hangul 테스트 123!!", LocaleKR)
	want := "한글 테스트"
	if got != want {
		t.Fatalf("NormalizeInputForMatch KR script filtering mismatch, got %q want %q", got, want)
	}
}

func TestNormalizeInputForMatch_PunctuationNormalization(t *testing.T) {
	// Full-width and separator punctuation should be normalized consistently
	input := "heat：damage・boost·test/ok"
	got := NormalizeInputForMatch(input, LocaleEN)
	want := "heat damage boost test ok"
	if got != want {
		t.Fatalf("NormalizeInputForMatch punctuation mismatch, got %q want %q (input %q)", got, want, input)
	}
}

func TestMatchOCR_MultilingualFuzzyExact(t *testing.T) {

```

If the actual normalization behavior differs slightly (for example, if multiple spaces are collapsed differently or if Kanji is treated differently per locale), adjust the `want` strings to match the existing `normalizeForMatch*` and `normalizePunctuation` implementations. Also ensure that `LocaleCN`, `LocaleTC`, `LocaleJP`, and `LocaleKR` are the correct locale identifiers used elsewhere in the codebase; if they are named differently, update the tests to use the appropriate constants.
</issue_to_address>