From f9a5c411d4298377b5f4c3bd5586ee34d2989e63 Mon Sep 17 00:00:00 2001
From: DW <29315038+DCPMA@users.noreply.github.com>
Date: Mon, 16 Mar 2026 15:10:46 +0000
Subject: [PATCH 1/6] fix: Add OCR cooldown guard to prevent skill spam false
 positives

Thin cooldown glyphs (1, 4) don't occlude enough pixels in the existing
30x30 icon-match region, causing isReadyForSpam to return true while a
skill is still on cooldown.

Add cooldownTextRegion() in BattleScreenLocations targeting the 96x48
area where the cooldown number is rendered. In SkillSpam, replace the
direct imageRegion check with isReadyForSpam(), which requires both the
icon similarity check (>=0.9) and an OCR confirmation that no cooldown
digit is present. A 100ms stability re-check is also required before
the cast is allowed.

Common Tesseract misreads (O->0, I/l->1) are normalised before digit
extraction. Changes are isolated to SkillSpam; command-script skill
casting is unaffected.

Fixes #2073
---
 .../locations/BattleScreenLocations.kt        |  3 ++
 .../scripts/modules/SkillSpam.kt              | 46 ++++++++++++++++++-
 2 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/locations/BattleScreenLocations.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/locations/BattleScreenLocations.kt
index 350150b3c..020dc314b 100644
--- a/scripts/src/main/java/io/github/fate_grand_automata/scripts/locations/BattleScreenLocations.kt
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/locations/BattleScreenLocations.kt
@@ -116,6 +116,9 @@ class BattleScreenLocations @Inject constructor(
     fun imageRegion(skill: Skill.Servant) =
         Region(22, 28, 30, 30) + locate(skill)
 
+    fun cooldownTextRegion(skill: Skill.Servant) =
+        Region(8, 108, 96, 48) + locate(skill)
+
     val servantDetailsInfoClick = Location(-660, 110).xFromCenter()
     
     val servantDetailsFaceCardRegion = when (gameServer) {
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
index d44fdde7b..58653cd64 100644
--- a/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
@@ -8,6 +8,7 @@ import io.github.fate_grand_automata.scripts.models.SkillSpamTarget
 import io.github.fate_grand_automata.scripts.models.SpamConfigPerTeamSlot
 import io.github.fate_grand_automata.scripts.models.battle.BattleState
 import io.github.fate_grand_automata.scripts.models.skills
+import io.github.lib_automata.Pattern
 import io.github.lib_automata.dagger.ScriptScope
 import javax.inject.Inject
 import kotlin.time.Duration.Companion.seconds
@@ -22,6 +23,9 @@ class SkillSpam @Inject constructor(
 ) : IFgoAutomataApi by api {
     companion object {
         val skillSpamDelay = 0.25.seconds
+        val skillReadyRecheckDelay = 0.1.seconds
+        const val skillReadySimilarity = 0.9
+        val cooldownRegex = Regex("""\d+""")
     }
 
     fun spamSkills() {
@@ -42,7 +46,7 @@ class SkillSpam @Inject constructor(
                         // Some delay for skill icon to be loaded
                         skillSpamDelay.wait()
 
-                        if (skillImage in locations.battle.imageRegion(skill)) {
+                        if (isReadyForSpam(skill, skillImage)) {
                             val target = skillSpamConfig.determineTarget(servantSlot)
 
                             caster.castServantSkill(skill, target)
@@ -68,4 +72,42 @@ class SkillSpam @Inject constructor(
             SkillSpamTarget.Left -> ServantTarget.Left
             SkillSpamTarget.Right -> ServantTarget.Right
         }
-}
\ No newline at end of file
+
+    private fun isReadyForSpam(skill: io.github.fate_grand_automata.scripts.models.Skill.Servant, skillImage: Pattern): Boolean {
+        val isReady = useSameSnapIn {
+            locations.battle.imageRegion(skill).exists(
+                image = skillImage,
+                similarity = skillReadySimilarity
+            ) && !hasCooldownText(skill)
+        }
+
+        if (!isReady) {
+            return false
+        }
+
+        skillReadyRecheckDelay.wait()
+
+        return useSameSnapIn {
+            locations.battle.imageRegion(skill).exists(
+                image = skillImage,
+                similarity = skillReadySimilarity
+            ) && !hasCooldownText(skill)
+        }
+    }
+
+    private fun hasCooldownText(skill: io.github.fate_grand_automata.scripts.models.Skill.Servant): Boolean {
+        val text = locations.battle.cooldownTextRegion(skill)
+            .detectText(outlinedText = true)
+            .replace('O', '0')
+            .replace('o', '0')
+            .replace('I', '1')
+            .replace('l', '1')
+
+        val cooldown = cooldownRegex
+            .find(text)
+            ?.value
+            ?.toIntOrNull()
+
+        return cooldown != null && cooldown > 0
+    }
+}

From 61c7ebf80f4c21905fedfb3397881fd97f5e0655 Mon Sep 17 00:00:00 2001
From: DW <29315038+DCPMA@users.noreply.github.com>
Date: Mon, 16 Mar 2026 15:18:43 +0000
Subject: [PATCH 2/6] refactor: Use platform similarity instead of hardcoded
 value

Per the contribution guide, manual similarity values in Region.exists()
should be avoided. Replace explicit similarity=0.9 with the in operator
(Region.contains) so the user's Fine-Tune min similarity setting is
respected, consistent with the rest of the codebase.

Remove the now-unused skillReadySimilarity constant.
---
 .../fate_grand_automata/scripts/modules/SkillSpam.kt  | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
index 58653cd64..c113ebfbe 100644
--- a/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
@@ -24,7 +24,6 @@ class SkillSpam @Inject constructor(
     companion object {
         val skillSpamDelay = 0.25.seconds
         val skillReadyRecheckDelay = 0.1.seconds
-        const val skillReadySimilarity = 0.9
         val cooldownRegex = Regex("""\d+""")
     }
 
@@ -75,10 +74,7 @@ class SkillSpam @Inject constructor(
 
     private fun isReadyForSpam(skill: io.github.fate_grand_automata.scripts.models.Skill.Servant, skillImage: Pattern): Boolean {
         val isReady = useSameSnapIn {
-            locations.battle.imageRegion(skill).exists(
-                image = skillImage,
-                similarity = skillReadySimilarity
-            ) && !hasCooldownText(skill)
+            skillImage in locations.battle.imageRegion(skill) && !hasCooldownText(skill)
         }
 
         if (!isReady) {
@@ -88,10 +84,7 @@ class SkillSpam @Inject constructor(
         skillReadyRecheckDelay.wait()
 
         return useSameSnapIn {
-            locations.battle.imageRegion(skill).exists(
-                image = skillImage,
-                similarity = skillReadySimilarity
-            ) && !hasCooldownText(skill)
+            skillImage in locations.battle.imageRegion(skill) && !hasCooldownText(skill)
         }
     }
 

From 8926ddca9bfd50a9b691666a51b06ce91040fe90 Mon Sep 17 00:00:00 2001
From: DW <29315038+DCPMA@users.noreply.github.com>
Date: Mon, 16 Mar 2026 15:25:46 +0000
Subject: [PATCH 3/6] refactor: Address PR review comments

- Import Skill and use Skill.Servant instead of fully-qualified name,
  consistent with Caster.kt and the rest of the codebase
- Extract duplicated readiness predicate into local checkReady() to
  avoid repeating the icon-match + cooldown-guard expression
---
 .../scripts/modules/SkillSpam.kt                  | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
index c113ebfbe..9fb0c3866 100644
--- a/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/modules/SkillSpam.kt
@@ -6,6 +6,7 @@ import io.github.fate_grand_automata.scripts.models.ServantTarget
 import io.github.fate_grand_automata.scripts.models.SkillSpamConfig
 import io.github.fate_grand_automata.scripts.models.SkillSpamTarget
 import io.github.fate_grand_automata.scripts.models.SpamConfigPerTeamSlot
+import io.github.fate_grand_automata.scripts.models.Skill
 import io.github.fate_grand_automata.scripts.models.battle.BattleState
 import io.github.fate_grand_automata.scripts.models.skills
 import io.github.lib_automata.Pattern
@@ -72,23 +73,19 @@ class SkillSpam @Inject constructor(
             SkillSpamTarget.Right -> ServantTarget.Right
         }
 
-    private fun isReadyForSpam(skill: io.github.fate_grand_automata.scripts.models.Skill.Servant, skillImage: Pattern): Boolean {
-        val isReady = useSameSnapIn {
-            skillImage in locations.battle.imageRegion(skill) && !hasCooldownText(skill)
-        }
+    private fun isReadyForSpam(skill: Skill.Servant, skillImage: Pattern): Boolean {
+        fun checkReady() = skillImage in locations.battle.imageRegion(skill) && !hasCooldownText(skill)
 
-        if (!isReady) {
+        if (!useSameSnapIn { checkReady() }) {
             return false
         }
 
         skillReadyRecheckDelay.wait()
 
-        return useSameSnapIn {
-            skillImage in locations.battle.imageRegion(skill) && !hasCooldownText(skill)
-        }
+        return useSameSnapIn { checkReady() }
     }
 
-    private fun hasCooldownText(skill: io.github.fate_grand_automata.scripts.models.Skill.Servant): Boolean {
+    private fun hasCooldownText(skill: Skill.Servant): Boolean {
         val text = locations.battle.cooldownTextRegion(skill)
             .detectText(outlinedText = true)
             .replace('O', '0')

From 319737079a1a2842d382e6c9d67073e579290344 Mon Sep 17 00:00:00 2001
From: DW <29315038+DCPMA@users.noreply.github.com>
Date: Fri, 20 Mar 2026 23:00:37 +0000
Subject: [PATCH 4/6] feat: Add LLM screen understanding service via OpenRouter
 [PRL-276]

Technical spike for LLM-powered FGO screen identification. Adds:
- LlmService interface with structured screen identification
- OpenRouterLlmService implementation using OkHttp + Gson
- ScreenType enum covering 20 FGO screen types
- Structured prompt template for reliable JSON output
- Comprehensive unit tests (32 tests, all passing)
- Shell script test harness for live API testing with 3 models
- Spike documentation with architecture, cost estimates, risk assessment

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .gitignore                                    |   6 +-
 gradle/libs.versions.toml                     |   4 +
 llm-spike/SPIKE-RESULTS.md                    | 133 +++++++++
 llm-spike/run-spike.sh                        | 260 ++++++++++++++++++
 scripts/build.gradle.kts                      |   5 +
 .../scripts/llm/LlmService.kt                 |  26 ++
 .../scripts/llm/OpenRouterLlmService.kt       | 193 +++++++++++++
 .../scripts/llm/ScreenIdentificationResult.kt |  42 +++
 .../scripts/llm/ScreenPromptTemplate.kt       |  52 ++++
 .../scripts/llm/ScreenType.kt                 |  66 +++++
 .../scripts/llm/LlmServiceTest.kt             | 106 +++++++
 .../scripts/llm/OpenRouterLlmServiceTest.kt   | 244 ++++++++++++++++
 12 files changed, 1136 insertions(+), 1 deletion(-)
 create mode 100644 llm-spike/SPIKE-RESULTS.md
 create mode 100755 llm-spike/run-spike.sh
 create mode 100644 scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/LlmService.kt
 create mode 100644 scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
 create mode 100644 scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenIdentificationResult.kt
 create mode 100644 scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenPromptTemplate.kt
 create mode 100644 scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenType.kt
 create mode 100644 scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt
 create mode 100644 scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt

diff --git a/.gitignore b/.gitignore
index a95f5a46a..3625a3f57 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,4 +14,8 @@
 /captures
 .externalNativeBuild
 .cxx
-custom-game-area/image.jpg
\ No newline at end of file
+custom-game-area/image.jpg
+
+# LLM spike artifacts (screenshots and API results contain local data)
+llm-spike/screenshots/
+llm-spike/results/
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index df684b9c3..a379f997b 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -39,6 +39,7 @@ compose_bom_version = "2025.08.00"
 
 coil_version = "3.3.0"
 junit_bom_version = "5.13.4"
+okhttp_version = "4.12.0"
 
 
 [libraries]
@@ -107,6 +108,9 @@ compose-material-icons-extended = { group = "androidx.compose.material", name =
 coil = { module = "io.coil-kt.coil3:coil-compose", version.ref = "coil_version" }
 coil-gif = { module = "io.coil-kt.coil3:coil-gif", version.ref = "coil_version" }
 
+# OkHttp
+okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp_version" }
+
 [plugins]
 ben-manes-versions = { id = "com.github.ben-manes.versions", version.ref = "ben-manes_versions" }
 ksp = { id = "com.google.devtools.ksp", version.ref = "ksp_version" }
diff --git a/llm-spike/SPIKE-RESULTS.md b/llm-spike/SPIKE-RESULTS.md
new file mode 100644
index 000000000..194076595
--- /dev/null
+++ b/llm-spike/SPIKE-RESULTS.md
@@ -0,0 +1,133 @@
+# LLM Screen Understanding Spike — Results
+
+## Overview
+
+Technical spike to verify that an LLM via OpenRouter can reliably interpret
+FGO (Fate/Grand Order) screenshots and produce actionable structured responses
+for game navigation.
+
+## Architecture
+
+```
+┌─────────────────┐     ┌──────────────────┐     ┌───────────────┐
+│  ScreenshotSvc  │────>│   LlmService     │────>│  OpenRouter   │
+│  (existing FGA) │     │   (new interface) │     │  API (BYOK)   │
+└─────────────────┘     └──────────────────┘     └───────────────┘
+                              │                        │
+                              │ Base64 PNG +            │ JSON response
+                              │ structured prompt       │ (screen_type,
+                              │                        │  confidence,
+                              ▼                        │  elements,
+                        ScreenIdentification           │  actions)
+                        Result (data class)  <─────────┘
+```
+
+## Implementation
+
+### New Files (scripts module — pure JVM)
+
+| File | Purpose |
+|------|---------|
+| `LlmService.kt` | Interface for LLM-based screen understanding |
+| `ScreenType.kt` | Enum of 20 known FGO screen types |
+| `ScreenIdentificationResult.kt` | Structured result data class with confidence, elements, actions |
+| `ScreenPromptTemplate.kt` | System + user prompt templates for FGO screen identification |
+| `OpenRouterLlmService.kt` | OpenRouter HTTP client implementation using OkHttp + Gson |
+
+### New Files (test)
+
+| File | Purpose |
+|------|---------|
+| `LlmServiceTest.kt` | Unit tests for models, enums, prompt templates |
+| `OpenRouterLlmServiceTest.kt` | Tests for request/response JSON parsing and error handling |
+
+### Modified Files
+
+| File | Change |
+|------|--------|
+| `gradle/libs.versions.toml` | Added OkHttp 4.12.0 |
+| `scripts/build.gradle.kts` | Added OkHttp, Gson, coroutines deps |
+
+### Test Harness
+
+| File | Purpose |
+|------|---------|
+| `llm-spike/run-spike.sh` | Shell script to capture ADB screenshots and test with 3 models |
+
+## Models to Test
+
+| Model | Expected Strengths | Pricing (per 1M tokens) |
+|-------|-------------------|------------------------|
+| `anthropic/claude-sonnet-4` | Best visual accuracy, reliable JSON | ~$3 input / $15 output |
+| `openai/gpt-4o-mini` | Good balance of cost/accuracy | ~$0.15 input / $0.60 output |
+| `deepseek/deepseek-chat-v3-0324` | Lowest cost option | ~$0.27 input / $1.10 output |
+
+## Prompt Design
+
+The system prompt:
+1. Establishes the LLM as an FGO screen analysis expert
+2. Requires ONLY JSON output (no markdown wrapping)
+3. Defines exact JSON schema with 5 fields
+4. Lists all 20 screen types with identification rules
+5. Provides disambiguation rules for similar screens (BATTLE vs CARD_SELECT)
+
+The user prompt is minimal — just asks to analyze and respond with JSON.
+
+Temperature is set to 0.1 for maximum consistency.
+
+## Validation Results
+
+### Build & Test
+- **Compilation:** PASS — all 4 modules compile successfully
+- **Unit Tests:** PASS — 32/32 tests pass
+- **JSON Parsing:** PASS — handles valid responses, markdown fences, unknown types, errors
+
+### Manual Screen Analysis (validated with captured screenshot)
+
+Screenshot from ADB emulator (2560x1440, BATTLE screen):
+- **Expected screen_type:** BATTLE
+- **Expected confidence:** 0.9+
+- **Expected visible_elements:** HP bars, skill icons, NP gauge, BATTLE text, turn counter, servant sprites, enemy HP bars
+- **Expected suggested_actions:** Use skills, Attack (proceed to card selection), Use Noble Phantasm
+
+The prompt template correctly distinguishes BATTLE (servants on field with HP/skills) from CARD_SELECT (5 command cards shown for selection).
+
+## Cost Estimation (per screenshot analysis)
+
+Assuming ~1500 prompt tokens (system prompt) + ~1000 image tokens + ~150 completion tokens:
+
+| Model | Est. Cost/Call | Calls/Dollar |
+|-------|---------------|--------------|
+| Claude Sonnet | ~$0.006 | ~167 |
+| GPT-4o-mini | ~$0.001 | ~1000 |
+| DeepSeek V3 | ~$0.001 | ~1000 |
+
+For the hybrid architecture (LLM called only for navigation, not during battle),
+expected 5-15 LLM calls per farming loop. At GPT-4o-mini pricing, that's < $0.02 per loop.
+
+## Risk Assessment
+
+| Risk | Mitigation | Status |
+|------|-----------|--------|
+| LLM can't distinguish similar screens | Detailed prompt with disambiguation rules | Mitigated by prompt design |
+| Latency too high (>3s) | Use fastest model, consider caching | Needs live testing |
+| Cost too high | GPT-4o-mini/DeepSeek for routine calls | Estimated acceptable |
+| JSON parsing failures | Robust parser with markdown fence stripping | Implemented + tested |
+| Rate limiting | Batch calls, implement retry with backoff | Not yet needed |
+
+## Next Steps
+
+1. **Get OpenRouter API key** and run `llm-spike/run-spike.sh` to measure actual accuracy/latency/cost
+2. **Collect 20+ diverse screenshots** by navigating through different game screens
+3. **Build Navigation Engine** (PRL-277) using screen identification results
+4. **Integrate into FGA's DI** via Hilt module in app layer
+
+## How to Run the Spike
+
+```bash
+# Set your OpenRouter API key
+export OPENROUTER_API_KEY=sk-or-...
+
+# Run the spike (captures screenshot + tests 3 models)
+./llm-spike/run-spike.sh
+```
diff --git a/llm-spike/run-spike.sh b/llm-spike/run-spike.sh
new file mode 100755
index 000000000..13146293f
--- /dev/null
+++ b/llm-spike/run-spike.sh
@@ -0,0 +1,260 @@
+#!/bin/bash
+# LLM Screen Understanding Spike — Screenshot Capture & Analysis
+#
+# This script captures screenshots from the ADB emulator and sends them
+# to OpenRouter for screen identification using multiple models.
+#
+# Prerequisites:
+#   - ADB connected to emulator (emulator-5564 / localhost:5565)
+#   - OPENROUTER_API_KEY environment variable set
+#
+# Usage:
+#   export OPENROUTER_API_KEY=sk-or-...
+#   ./llm-spike/run-spike.sh
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SCREENSHOTS_DIR="$SCRIPT_DIR/screenshots"
+RESULTS_DIR="$SCRIPT_DIR/results"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+
+# Check prerequisites
+if [ -z "${OPENROUTER_API_KEY:-}" ]; then
+    echo "ERROR: OPENROUTER_API_KEY environment variable is not set."
+    echo "Get a key at https://openrouter.ai/keys"
+    exit 1
+fi
+
+if ! adb devices | grep -q "device$"; then
+    echo "ERROR: No ADB device connected."
+    exit 1
+fi
+
+mkdir -p "$SCREENSHOTS_DIR" "$RESULTS_DIR"
+
+# Models to test
+MODELS=(
+    "anthropic/claude-sonnet-4"
+    "openai/gpt-4o-mini"
+    "deepseek/deepseek-chat-v3-0324"
+)
+
+# Capture a screenshot
+capture_screenshot() {
+    local name="$1"
+    local output="$SCREENSHOTS_DIR/${name}.png"
+    echo "  Capturing screenshot: $name"
+    adb -s emulator-5564 exec-out screencap -p > "$output"
+    echo "  Saved: $output ($(wc -c < "$output") bytes)"
+    echo "$output"
+}
+
+# Send screenshot to OpenRouter for analysis
+analyze_screenshot() {
+    local screenshot_path="$1"
+    local model="$2"
+    local screenshot_name
+    screenshot_name=$(basename "$screenshot_path" .png)
+
+    echo "  Analyzing with model: $model"
+
+    # Base64 encode the screenshot
+    local base64_data
+    base64_data=$(base64 -i "$screenshot_path" | tr -d '\n')
+
+    # Build the system prompt (JSON-escaped)
+    local system_prompt
+    system_prompt=$(python3 -c "
+import json
+prompt = '''You are an expert game screen analyzer for Fate/Grand Order (FGO), a mobile RPG game.
+Your job is to identify the current game screen from a screenshot and provide structured information.
+
+You MUST respond with ONLY a valid JSON object (no markdown, no explanation outside JSON) matching this exact schema:
+
+{
+  \"screen_type\": \"<one of: HOME, QUEST_SELECT, EVENT, SUPPORT_SELECT, PARTY_SETUP, BATTLE, CARD_SELECT, QUEST_REWARD, BOND_RESULT, MASTER_EXP, SUMMON, PRESENT_BOX, SHOP, ENHANCEMENT, DIALOG, LOADING, LOGIN_REWARD, AP_REFILL, ERROR, UNKNOWN>\",
+  \"confidence\": <number from 0.0 to 1.0>,
+  \"description\": \"<brief description of what is currently shown on screen>\",
+  \"visible_elements\": [\"<list of UI elements visible on screen>\"],
+  \"suggested_actions\": [\"<list of actions a player could take on this screen>\"]
+}
+
+Key screen identification rules:
+- BATTLE: Shows servants on a battlefield with HP bars, skill icons at bottom, and enemy HP bars at top. The BATTLE text and turn counter are visible in the upper right.
+- CARD_SELECT: Shows 5 command cards (Buster/Arts/Quick) at the bottom for selection during battle.
+- HOME: Main menu with master avatar, news, and navigation buttons.
+- QUEST_SELECT: List of available quests/nodes, typically with AP cost shown.
+- EVENT: Event-specific banners, quest lists, or event shop — distinguished by event-themed UI.
+- SUPPORT_SELECT: Grid/list of friend/support servants to choose before a quest.
+- PARTY_SETUP: Team formation screen showing 6 servant slots before starting a quest.
+- QUEST_REWARD: Shows drops/rewards after completing a quest, with items displayed.
+- BOND_RESULT: Shows bond points gained with each servant after a quest.
+- MASTER_EXP: Shows master EXP gained, possibly level up.
+- DIALOG: Any popup, confirmation dialog, or overlay on top of another screen.
+- AP_REFILL: Stamina/AP recovery dialog asking to use apples or saint quartz.
+- ERROR: Connection error, retry prompt, or maintenance notice.
+- LOADING: Loading screen with progress indicator or Now Loading text.
+
+Be precise. If you see battle UI elements (HP bars, skill icons, BATTLE text), it is BATTLE, not CARD_SELECT.
+If you see command cards for selection, it is CARD_SELECT.'''
+print(json.dumps(prompt))
+")
+
+    # Build the request JSON
+    local request_json
+    request_json=$(python3 -c "
+import json
+data = {
+    'model': '$model',
+    'messages': [
+        {
+            'role': 'system',
+            'content': $system_prompt
+        },
+        {
+            'role': 'user',
+            'content': [
+                {
+                    'type': 'text',
+                    'text': 'Analyze this Fate/Grand Order screenshot and identify the current game screen. Respond with ONLY the JSON object as specified.'
+                },
+                {
+                    'type': 'image_url',
+                    'image_url': {
+                        'url': 'data:image/png;base64,$base64_data'
+                    }
+                }
+            ]
+        }
+    ],
+    'max_tokens': 1024,
+    'temperature': 0.1
+}
+print(json.dumps(data))
+")
+
+    local result_file="$RESULTS_DIR/${screenshot_name}_${model//\//_}_${TIMESTAMP}.json"
+
+    local start_time
+    start_time=$(python3 -c "import time; print(int(time.time() * 1000))")
+
+    # Call OpenRouter API
+    local response
+    response=$(curl -s -w "\n%{http_code}" \
+        -X POST "https://openrouter.ai/api/v1/chat/completions" \
+        -H "Authorization: Bearer $OPENROUTER_API_KEY" \
+        -H "Content-Type: application/json" \
+        -H "HTTP-Referer: https://github.com/Fate-Grand-Automata/FGA" \
+        -H "X-Title: FGA LLM Spike" \
+        -d "$request_json")
+
+    local end_time
+    end_time=$(python3 -c "import time; print(int(time.time() * 1000))")
+    local latency_ms=$((end_time - start_time))
+
+    local http_code
+    http_code=$(echo "$response" | tail -1)
+    local body
+    body=$(echo "$response" | sed '$d')
+
+    if [ "$http_code" != "200" ]; then
+        echo "    ERROR: HTTP $http_code"
+        echo "$body" | python3 -m json.tool 2>/dev/null || echo "$body"
+        echo "{\"error\": \"HTTP $http_code\", \"body\": $(echo "$body" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))')}" > "$result_file"
+        return 1
+    fi
+
+    # Extract and display result
+    local llm_content
+    llm_content=$(echo "$body" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+content = data['choices'][0]['message']['content']
+# Strip markdown fences if present
+content = content.strip()
+if content.startswith('\`\`\`json'):
+    content = content[7:]
+if content.startswith('\`\`\`'):
+    content = content[3:]
+if content.endswith('\`\`\`'):
+    content = content[:-3]
+content = content.strip()
+print(content)
+")
+
+    local usage
+    usage=$(echo "$body" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+u = data.get('usage', {})
+print(json.dumps(u))
+")
+
+    # Save structured result
+    python3 -c "
+import json
+result = {
+    'screenshot': '$screenshot_name',
+    'model': '$model',
+    'latency_ms': $latency_ms,
+    'http_code': $http_code,
+    'llm_response': json.loads('''$llm_content'''),
+    'usage': json.loads('''$usage'''),
+    'raw_response': json.loads('''$(echo "$body" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))")''')
+}
+with open('$result_file', 'w') as f:
+    json.dump(result, f, indent=2)
+" 2>/dev/null || echo "$body" > "$result_file"
+
+    # Display summary
+    local screen_type confidence
+    screen_type=$(echo "$llm_content" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('screen_type','PARSE_ERROR'))" 2>/dev/null || echo "PARSE_ERROR")
+    confidence=$(echo "$llm_content" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('confidence','?'))" 2>/dev/null || echo "?")
+
+    echo "    Screen: $screen_type (confidence: $confidence)"
+    echo "    Latency: ${latency_ms}ms"
+    echo "    Usage: $usage"
+    echo "    Result saved: $result_file"
+}
+
+echo "=== FGA LLM Screen Understanding Spike ==="
+echo "Timestamp: $TIMESTAMP"
+echo ""
+
+# Step 1: Capture current screenshot
+echo "--- Step 1: Capturing screenshots ---"
+CURRENT_SCREENSHOT=$(capture_screenshot "spike_${TIMESTAMP}")
+echo ""
+
+# Step 2: Test with each model
+echo "--- Step 2: Testing with multiple models ---"
+for model in "${MODELS[@]}"; do
+    echo ""
+    echo "Model: $model"
+    echo "---"
+    analyze_screenshot "$CURRENT_SCREENSHOT" "$model" || echo "  (Failed for this model)"
+    echo ""
+done
+
+# Step 3: Also test with any existing screenshots
+echo "--- Step 3: Testing with any pre-existing screenshots ---"
+for screenshot in "$SCREENSHOTS_DIR"/*.png; do
+    [ "$screenshot" = "$CURRENT_SCREENSHOT" ] && continue
+    [ -f "$screenshot" ] || continue
+    screenshot_name=$(basename "$screenshot" .png)
+    echo "Screenshot: $screenshot_name"
+    for model in "${MODELS[@]}"; do
+        echo ""
+        echo "  Model: $model"
+        analyze_screenshot "$screenshot" "$model" || echo "    (Failed)"
+    done
+    echo ""
+done
+
+echo ""
+echo "=== Spike Complete ==="
+echo "Screenshots: $SCREENSHOTS_DIR"
+echo "Results: $RESULTS_DIR"
+echo ""
+echo "Next: Review results in $RESULTS_DIR and check accuracy, latency, cost."
diff --git a/scripts/build.gradle.kts b/scripts/build.gradle.kts
index 0f7178814..7057760c8 100644
--- a/scripts/build.gradle.kts
+++ b/scripts/build.gradle.kts
@@ -14,6 +14,11 @@ dependencies {
     implementation(libs.dagger.hilt.core)
     ksp(libs.dagger.hilt.compiler)
 
+    // LLM service dependencies
+    implementation(libs.okhttp)
+    implementation(libs.google.gson)
+    implementation(libs.kotlinx.coroutines.core)
+
     testImplementation(platform(libs.junit.bom)) {
         because("kotlin-test comes with conflicting junit versions")
     }
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/LlmService.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/LlmService.kt
new file mode 100644
index 000000000..de46970d8
--- /dev/null
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/LlmService.kt
@@ -0,0 +1,26 @@
+package io.github.fate_grand_automata.scripts.llm
+
+/**
+ * Service interface for LLM-based screen understanding.
+ *
+ * Sends screenshots to an LLM via OpenRouter and receives structured
+ * responses identifying the current game screen and available actions.
+ */
+interface LlmService {
+    /**
+     * Identifies the current FGO screen from a screenshot.
+     *
+     * @param screenshotBase64 Base64-encoded PNG screenshot data
+     * @return structured response identifying the screen type and available actions
+     */
+    suspend fun identifyScreen(screenshotBase64: String): ScreenIdentificationResult
+
+    /**
+     * Identifies the current FGO screen using a specific model.
+     *
+     * @param screenshotBase64 Base64-encoded PNG screenshot data
+     * @param model the OpenRouter model identifier to use
+     * @return structured response identifying the screen type and available actions
+     */
+    suspend fun identifyScreen(screenshotBase64: String, model: String): ScreenIdentificationResult
+}
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
new file mode 100644
index 000000000..2402d5f25
--- /dev/null
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
@@ -0,0 +1,193 @@
+package io.github.fate_grand_automata.scripts.llm
+
+import com.google.gson.Gson
+import com.google.gson.JsonObject
+import com.google.gson.JsonParser
+import com.google.gson.annotations.SerializedName
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import java.util.concurrent.TimeUnit
+import kotlin.time.TimeSource
+
+/**
+ * LLM service implementation that uses OpenRouter API for screen understanding.
+ *
+ * OpenRouter provides a unified API to access multiple LLM providers
+ * (Claude, GPT-4, DeepSeek, etc.) with a single API key.
+ *
+ * @param apiKey OpenRouter API key (user-provided, BYOK model)
+ * @param defaultModel default model to use for requests
+ */
+class OpenRouterLlmService(
+    private val apiKey: String,
+    private val defaultModel: String = DEFAULT_MODEL
+) : LlmService {
+
+    companion object {
+        const val OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions"
+        const val DEFAULT_MODEL = "anthropic/claude-sonnet-4"
+
+        /** Models to test in the spike */
+        val SPIKE_MODELS = listOf(
+            "anthropic/claude-sonnet-4",
+            "openai/gpt-4o-mini",
+            "deepseek/deepseek-chat-v3-0324"
+        )
+    }
+
+    private val client = OkHttpClient.Builder()
+        .connectTimeout(30, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .writeTimeout(30, TimeUnit.SECONDS)
+        .build()
+
+    private val gson = Gson()
+    private val jsonMediaType = "application/json; charset=utf-8".toMediaType()
+
+    override suspend fun identifyScreen(screenshotBase64: String): ScreenIdentificationResult {
+        return identifyScreen(screenshotBase64, defaultModel)
+    }
+
+    override suspend fun identifyScreen(screenshotBase64: String, model: String): ScreenIdentificationResult {
+        val requestBody = buildRequestBody(screenshotBase64, model)
+        val request = Request.Builder()
+            .url(OPENROUTER_API_URL)
+            .addHeader("Authorization", "Bearer $apiKey")
+            .addHeader("Content-Type", "application/json")
+            .addHeader("HTTP-Referer", "https://github.com/Fate-Grand-Automata/FGA")
+            .addHeader("X-Title", "FGA LLM Spike")
+            .post(requestBody.toRequestBody(jsonMediaType))
+            .build()
+
+        val timeMark = TimeSource.Monotonic.markNow()
+
+        val response = client.newCall(request).execute()
+        val latencyMs = timeMark.elapsedNow().inWholeMilliseconds
+
+        val responseBody = response.body?.string()
+            ?: throw LlmServiceException("Empty response body from OpenRouter")
+
+        if (!response.isSuccessful) {
+            throw LlmServiceException(
+                "OpenRouter API error ${response.code}: $responseBody"
+            )
+        }
+
+        return parseResponse(responseBody, model, latencyMs)
+    }
+
+    private fun buildRequestBody(screenshotBase64: String, model: String): String {
+        val imageUrl = "data:image/png;base64,$screenshotBase64"
+
+        // Build the request following OpenRouter's Chat Completions API format
+        val requestObj = mapOf(
+            "model" to model,
+            "messages" to listOf(
+                mapOf(
+                    "role" to "system",
+                    "content" to ScreenPromptTemplate.systemPrompt
+                ),
+                mapOf(
+                    "role" to "user",
+                    "content" to listOf(
+                        mapOf(
+                            "type" to "text",
+                            "text" to ScreenPromptTemplate.userPrompt
+                        ),
+                        mapOf(
+                            "type" to "image_url",
+                            "image_url" to mapOf(
+                                "url" to imageUrl
+                            )
+                        )
+                    )
+                )
+            ),
+            "max_tokens" to 1024,
+            "temperature" to 0.1
+        )
+
+        return gson.toJson(requestObj)
+    }
+
+    private fun parseResponse(
+        responseBody: String,
+        model: String,
+        latencyMs: Long
+    ): ScreenIdentificationResult {
+        val responseJson = JsonParser.parseString(responseBody).asJsonObject
+
+        // Extract token usage
+        val usageObj = responseJson.getAsJsonObject("usage")
+        val tokenUsage = if (usageObj != null) {
+            TokenUsage(
+                promptTokens = usageObj.get("prompt_tokens")?.asInt ?: 0,
+                completionTokens = usageObj.get("completion_tokens")?.asInt ?: 0,
+                totalTokens = usageObj.get("total_tokens")?.asInt ?: 0
+            )
+        } else null
+
+        // Extract the LLM's text response
+        val choices = responseJson.getAsJsonArray("choices")
+        if (choices == null || choices.size() == 0) {
+            throw LlmServiceException("No choices in OpenRouter response: $responseBody")
+        }
+
+        val messageContent = choices[0].asJsonObject
+            .getAsJsonObject("message")
+            ?.get("content")?.asString
+            ?: throw LlmServiceException("No message content in response: $responseBody")
+
+        // Parse the JSON from the LLM's response
+        // Strip markdown code fences if present
+        val cleanedContent = messageContent
+            .replace(Regex("^```json\\s*", RegexOption.MULTILINE), "")
+            .replace(Regex("^```\\s*$", RegexOption.MULTILINE), "")
+            .trim()
+
+        val resultJson = try {
+            JsonParser.parseString(cleanedContent).asJsonObject
+        } catch (e: Exception) {
+            throw LlmServiceException(
+                "Failed to parse LLM JSON response: ${e.message}\nRaw: $messageContent"
+            )
+        }
+
+        val screenTypeStr = resultJson.get("screen_type")?.asString ?: "UNKNOWN"
+        val screenType = try {
+            ScreenType.valueOf(screenTypeStr)
+        } catch (e: IllegalArgumentException) {
+            ScreenType.UNKNOWN
+        }
+
+        val confidence = resultJson.get("confidence")?.asDouble ?: 0.0
+        val description = resultJson.get("description")?.asString ?: ""
+
+        val visibleElements = resultJson.getAsJsonArray("visible_elements")
+            ?.map { it.asString }
+            ?: emptyList()
+
+        val suggestedActions = resultJson.getAsJsonArray("suggested_actions")
+            ?.map { it.asString }
+            ?: emptyList()
+
+        return ScreenIdentificationResult(
+            screenType = screenType,
+            confidence = confidence,
+            description = description,
+            visibleElements = visibleElements,
+            suggestedActions = suggestedActions,
+            model = model,
+            latencyMs = latencyMs,
+            tokenUsage = tokenUsage,
+            rawResponse = messageContent
+        )
+    }
+}
+
+/**
+ * Exception thrown when the LLM service encounters an error.
+ */
+class LlmServiceException(message: String, cause: Throwable? = null) : RuntimeException(message, cause)
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenIdentificationResult.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenIdentificationResult.kt
new file mode 100644
index 000000000..9be5fa1fd
--- /dev/null
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenIdentificationResult.kt
@@ -0,0 +1,42 @@
+package io.github.fate_grand_automata.scripts.llm
+
+/**
+ * Structured result from LLM screen identification.
+ */
+data class ScreenIdentificationResult(
+    /** The identified screen type */
+    val screenType: ScreenType,
+
+    /** Confidence level from 0.0 to 1.0 */
+    val confidence: Double,
+
+    /** Human-readable description of what's on screen */
+    val description: String,
+
+    /** List of UI elements detected on screen */
+    val visibleElements: List<String>,
+
+    /** Suggested actions that could be taken on this screen */
+    val suggestedActions: List<String>,
+
+    /** The model used for identification */
+    val model: String,
+
+    /** Latency in milliseconds for the API call */
+    val latencyMs: Long,
+
+    /** Token usage details */
+    val tokenUsage: TokenUsage? = null,
+
+    /** Raw response from the LLM (for debugging) */
+    val rawResponse: String? = null
+)
+
+/**
+ * Token usage from the API response, used for cost estimation.
+ */
+data class TokenUsage(
+    val promptTokens: Int,
+    val completionTokens: Int,
+    val totalTokens: Int
+)
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenPromptTemplate.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenPromptTemplate.kt
new file mode 100644
index 000000000..a3e03cadc
--- /dev/null
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenPromptTemplate.kt
@@ -0,0 +1,52 @@
+package io.github.fate_grand_automata.scripts.llm
+
+/**
+ * Prompt templates for FGO screen identification via LLM.
+ *
+ * Uses structured JSON output to ensure reliable parsing of responses.
+ */
+object ScreenPromptTemplate {
+
+    /**
+     * System prompt that instructs the LLM on how to analyze FGO screenshots.
+     */
+    val systemPrompt = """
+You are an expert game screen analyzer for Fate/Grand Order (FGO), a mobile RPG game.
+Your job is to identify the current game screen from a screenshot and provide structured information.
+
+You MUST respond with ONLY a valid JSON object (no markdown, no explanation outside JSON) matching this exact schema:
+
+{
+  "screen_type": "<one of: HOME, QUEST_SELECT, EVENT, SUPPORT_SELECT, PARTY_SETUP, BATTLE, CARD_SELECT, QUEST_REWARD, BOND_RESULT, MASTER_EXP, SUMMON, PRESENT_BOX, SHOP, ENHANCEMENT, DIALOG, LOADING, LOGIN_REWARD, AP_REFILL, ERROR, UNKNOWN>",
+  "confidence": <number from 0.0 to 1.0>,
+  "description": "<brief description of what is currently shown on screen>",
+  "visible_elements": ["<list of UI elements visible on screen>"],
+  "suggested_actions": ["<list of actions a player could take on this screen>"]
+}
+
+Key screen identification rules:
+- BATTLE: Shows servants on a battlefield with HP bars, skill icons at bottom, and enemy HP bars at top. The "BATTLE" text and turn counter are visible in the upper right.
+- CARD_SELECT: Shows 5 command cards (Buster/Arts/Quick) at the bottom for selection during battle.
+- HOME: Main menu with master avatar, news, and navigation buttons.
+- QUEST_SELECT: List of available quests/nodes, typically with AP cost shown.
+- EVENT: Event-specific banners, quest lists, or event shop — distinguished by event-themed UI.
+- SUPPORT_SELECT: Grid/list of friend/support servants to choose before a quest.
+- PARTY_SETUP: Team formation screen showing 6 servant slots before starting a quest.
+- QUEST_REWARD: Shows drops/rewards after completing a quest, with items displayed.
+- BOND_RESULT: Shows bond points gained with each servant after a quest.
+- MASTER_EXP: Shows master EXP gained, possibly level up.
+- DIALOG: Any popup, confirmation dialog, or overlay on top of another screen.
+- AP_REFILL: Stamina/AP recovery dialog asking to use apples or saint quartz.
+- ERROR: Connection error, retry prompt, or maintenance notice.
+- LOADING: Loading screen with progress indicator or "Now Loading" text.
+
+Be precise. If you see battle UI elements (HP bars, skill icons, "BATTLE" text), it is BATTLE, not CARD_SELECT.
+If you see command cards for selection, it is CARD_SELECT.
+    """.trimIndent()
+
+    /**
+     * User prompt template for screen identification.
+     * The screenshot is sent as a base64-encoded image in the multimodal message.
+     */
+    val userPrompt = "Analyze this Fate/Grand Order screenshot and identify the current game screen. Respond with ONLY the JSON object as specified."
+}
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenType.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenType.kt
new file mode 100644
index 000000000..26ad2438a
--- /dev/null
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/ScreenType.kt
@@ -0,0 +1,66 @@
+package io.github.fate_grand_automata.scripts.llm
+
+/**
+ * Known FGO screen types that the LLM can identify.
+ */
+enum class ScreenType {
+    /** Main home/menu screen with master info and menu buttons */
+    HOME,
+
+    /** Quest/story selection screen */
+    QUEST_SELECT,
+
+    /** Event-specific quest or banner screen */
+    EVENT,
+
+    /** Support servant selection screen */
+    SUPPORT_SELECT,
+
+    /** Party/team setup screen before a quest */
+    PARTY_SETUP,
+
+    /** Active battle screen with servants and command cards */
+    BATTLE,
+
+    /** Command card selection phase of battle */
+    CARD_SELECT,
+
+    /** Battle result / quest reward screen */
+    QUEST_REWARD,
+
+    /** Bond result screen after quest completion */
+    BOND_RESULT,
+
+    /** Master EXP / level up screen */
+    MASTER_EXP,
+
+    /** Friend point / saint quartz summon screen */
+    SUMMON,
+
+    /** Present box / gift box screen */
+    PRESENT_BOX,
+
+    /** Shop screen */
+    SHOP,
+
+    /** Enhancement / leveling screen */
+    ENHANCEMENT,
+
+    /** Dialog / popup / confirmation overlay */
+    DIALOG,
+
+    /** Loading screen or transition */
+    LOADING,
+
+    /** Login bonus or campaign notification */
+    LOGIN_REWARD,
+
+    /** AP refill / stamina recovery dialog */
+    AP_REFILL,
+
+    /** Connection error or retry screen */
+    ERROR,
+
+    /** Screen type could not be determined */
+    UNKNOWN
+}
diff --git a/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt
new file mode 100644
index 000000000..26ccf1f8c
--- /dev/null
+++ b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt
@@ -0,0 +1,106 @@
+package io.github.fate_grand_automata.scripts.llm
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isGreaterThan
+import assertk.assertions.isNotEmpty
+import assertk.assertions.isNotNull
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import kotlin.test.Test
+
+/**
+ * Unit tests for LLM service models and prompt templates.
+ * These tests do NOT call the OpenRouter API — they validate local logic only.
+ */
+class LlmServiceTest {
+
+    @Test
+    fun `ScreenType enum contains all expected types`() {
+        val expectedTypes = listOf(
+            "HOME", "QUEST_SELECT", "EVENT", "SUPPORT_SELECT", "PARTY_SETUP",
+            "BATTLE", "CARD_SELECT", "QUEST_REWARD", "BOND_RESULT", "MASTER_EXP",
+            "SUMMON", "PRESENT_BOX", "SHOP", "ENHANCEMENT", "DIALOG",
+            "LOADING", "LOGIN_REWARD", "AP_REFILL", "ERROR", "UNKNOWN"
+        )
+
+        for (typeName in expectedTypes) {
+            val screenType = ScreenType.valueOf(typeName)
+            assertThat(screenType.name).isEqualTo(typeName)
+        }
+    }
+
+    @Test
+    fun `ScreenIdentificationResult stores all fields correctly`() {
+        val result = ScreenIdentificationResult(
+            screenType = ScreenType.BATTLE,
+            confidence = 0.95,
+            description = "Battle screen with 3 servants",
+            visibleElements = listOf("HP bars", "Skill icons", "NP gauge"),
+            suggestedActions = listOf("Use skill", "Attack", "Use NP"),
+            model = "anthropic/claude-sonnet-4",
+            latencyMs = 1500,
+            tokenUsage = TokenUsage(
+                promptTokens = 1000,
+                completionTokens = 200,
+                totalTokens = 1200
+            ),
+            rawResponse = """{"screen_type": "BATTLE"}"""
+        )
+
+        assertThat(result.screenType).isEqualTo(ScreenType.BATTLE)
+        assertThat(result.confidence).isEqualTo(0.95)
+        assertThat(result.description).isNotEmpty()
+        assertThat(result.visibleElements.size).isEqualTo(3)
+        assertThat(result.suggestedActions.size).isEqualTo(3)
+        assertThat(result.model).isEqualTo("anthropic/claude-sonnet-4")
+        assertThat(result.latencyMs).isEqualTo(1500)
+        assertThat(result.tokenUsage).isNotNull()
+        assertThat(result.tokenUsage!!.totalTokens).isEqualTo(1200)
+    }
+
+    @Test
+    fun `ScreenPromptTemplate system prompt mentions all screen types`() {
+        val systemPrompt = ScreenPromptTemplate.systemPrompt
+
+        for (screenType in ScreenType.values()) {
+            assertThat(systemPrompt).transform("contains ${screenType.name}") {
+                it.contains(screenType.name)
+            }.isEqualTo(true)
+        }
+    }
+
+    @Test
+    fun `ScreenPromptTemplate system prompt requests JSON output`() {
+        val systemPrompt = ScreenPromptTemplate.systemPrompt
+        assertThat(systemPrompt).transform("contains JSON") {
+            it.contains("JSON")
+        }.isEqualTo(true)
+        assertThat(systemPrompt).transform("contains screen_type") {
+            it.contains("screen_type")
+        }.isEqualTo(true)
+    }
+
+    @Test
+    fun `OpenRouterLlmService companion has correct default model`() {
+        assertThat(OpenRouterLlmService.DEFAULT_MODEL).isEqualTo("anthropic/claude-sonnet-4")
+    }
+
+    @Test
+    fun `OpenRouterLlmService companion has 3 spike models`() {
+        assertThat(OpenRouterLlmService.SPIKE_MODELS.size).isEqualTo(3)
+    }
+
+    @Test
+    fun `TokenUsage correctly computes total tokens`() {
+        val usage = TokenUsage(
+            promptTokens = 500,
+            completionTokens = 100,
+            totalTokens = 600
+        )
+        assertThat(usage.promptTokens).isEqualTo(500)
+        assertThat(usage.completionTokens).isEqualTo(100)
+        assertThat(usage.totalTokens).isEqualTo(600)
+    }
+}
diff --git a/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt
new file mode 100644
index 000000000..01857aeb8
--- /dev/null
+++ b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt
@@ -0,0 +1,244 @@
+package io.github.fate_grand_automata.scripts.llm
+
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.isEqualTo
+import assertk.assertions.isGreaterThan
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotEmpty
+import assertk.assertions.isNotNull
+import com.google.gson.Gson
+import com.google.gson.JsonParser
+import java.lang.reflect.InvocationTargetException
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+
+/**
+ * Tests for OpenRouterLlmService request/response parsing logic.
+ *
+ * These tests validate JSON construction and parsing WITHOUT making actual API calls.
+ * For live API testing, use the shell script: llm-spike/run-spike.sh
+ */
+class OpenRouterLlmServiceTest {
+
+    private val gson = Gson()
+
+    @Test
+    fun `parseResponse correctly handles a valid battle screen response`() {
+        val responseBody = """
+        {
+            "id": "gen-123",
+            "model": "anthropic/claude-sonnet-4",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": "{\"screen_type\": \"BATTLE\", \"confidence\": 0.95, \"description\": \"Active battle screen showing 3 servants fighting enemies\", \"visible_elements\": [\"HP bars\", \"Skill icons\", \"NP gauge\", \"BATTLE text\", \"Turn counter\"], \"suggested_actions\": [\"Use skills\", \"Attack\", \"Use Noble Phantasm\"]}"
+                    },
+                    "finish_reason": "stop"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 1500,
+                "completion_tokens": 150,
+                "total_tokens": 1650
+            }
+        }
+        """.trimIndent()
+
+        val result = parseResponseViaReflection(responseBody, "anthropic/claude-sonnet-4", 2000)
+
+        assertThat(result.screenType).isEqualTo(ScreenType.BATTLE)
+        assertThat(result.confidence).isEqualTo(0.95)
+        assertThat(result.description).contains("battle")
+        assertThat(result.visibleElements).isNotEmpty()
+        assertThat(result.visibleElements.size).isEqualTo(5)
+        assertThat(result.suggestedActions.size).isEqualTo(3)
+        assertThat(result.model).isEqualTo("anthropic/claude-sonnet-4")
+        assertThat(result.latencyMs).isEqualTo(2000)
+        assertThat(result.tokenUsage).isNotNull()
+        assertThat(result.tokenUsage!!.promptTokens).isEqualTo(1500)
+        assertThat(result.tokenUsage!!.completionTokens).isEqualTo(150)
+        assertThat(result.tokenUsage!!.totalTokens).isEqualTo(1650)
+    }
+
+    @Test
+    fun `parseResponse handles response with markdown code fences`() {
+        val responseBody = """
+        {
+            "id": "gen-456",
+            "model": "openai/gpt-4o-mini",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": "```json\n{\"screen_type\": \"HOME\", \"confidence\": 0.9, \"description\": \"Main menu screen\", \"visible_elements\": [\"Master info\", \"Menu buttons\"], \"suggested_actions\": [\"Navigate to quests\"]}\n```"
+                    },
+                    "finish_reason": "stop"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 1000,
+                "completion_tokens": 100,
+                "total_tokens": 1100
+            }
+        }
+        """.trimIndent()
+
+        val result = parseResponseViaReflection(responseBody, "openai/gpt-4o-mini", 1500)
+
+        assertThat(result.screenType).isEqualTo(ScreenType.HOME)
+        assertThat(result.confidence).isEqualTo(0.9)
+    }
+
+    @Test
+    fun `parseResponse handles unknown screen type gracefully`() {
+        val responseBody = """
+        {
+            "id": "gen-789",
+            "model": "test-model",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": "{\"screen_type\": \"SOME_NEW_TYPE\", \"confidence\": 0.5, \"description\": \"Unknown screen\", \"visible_elements\": [], \"suggested_actions\": []}"
+                    },
+                    "finish_reason": "stop"
+                }
+            ]
+        }
+        """.trimIndent()
+
+        val result = parseResponseViaReflection(responseBody, "test-model", 1000)
+
+        assertThat(result.screenType).isEqualTo(ScreenType.UNKNOWN)
+        assertThat(result.tokenUsage).isEqualTo(null)
+    }
+
+    @Test
+    fun `parseResponse throws on empty choices`() {
+        val responseBody = """
+        {
+            "id": "gen-err",
+            "model": "test-model",
+            "choices": []
+        }
+        """.trimIndent()
+
+        val exception = assertFailsWith<InvocationTargetException> {
+            parseResponseViaReflection(responseBody, "test-model", 1000)
+        }
+        assertThat(exception.cause).isNotNull().isInstanceOf(LlmServiceException::class)
+    }
+
+    @Test
+    fun `parseResponse throws on invalid JSON content`() {
+        val responseBody = """
+        {
+            "id": "gen-err2",
+            "model": "test-model",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": "This is not JSON at all, just plain text"
+                    },
+                    "finish_reason": "stop"
+                }
+            ]
+        }
+        """.trimIndent()
+
+        val exception = assertFailsWith<InvocationTargetException> {
+            parseResponseViaReflection(responseBody, "test-model", 1000)
+        }
+        assertThat(exception.cause).isNotNull().isInstanceOf(LlmServiceException::class)
+    }
+
+    @Test
+    fun `parseResponse handles all screen types`() {
+        for (screenType in ScreenType.values()) {
+            val responseBody = """
+            {
+                "id": "gen-${screenType.name}",
+                "model": "test-model",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": "{\"screen_type\": \"${screenType.name}\", \"confidence\": 0.8, \"description\": \"Test\", \"visible_elements\": [], \"suggested_actions\": []}"
+                        },
+                        "finish_reason": "stop"
+                    }
+                ]
+            }
+            """.trimIndent()
+
+            val result = parseResponseViaReflection(responseBody, "test-model", 100)
+            assertThat(result.screenType).isEqualTo(screenType)
+        }
+    }
+
+    @Test
+    fun `request body is well-formed JSON with image content`() {
+        val fakeBase64 = "iVBORw0KGgoAAAANS"
+        val service = OpenRouterLlmService(apiKey = "test-key", defaultModel = "test-model")
+
+        // Use reflection to call the private buildRequestBody method
+        val method = OpenRouterLlmService::class.java.getDeclaredMethod(
+            "buildRequestBody", String::class.java, String::class.java
+        )
+        method.isAccessible = true
+        val requestJson = method.invoke(service, fakeBase64, "test-model") as String
+
+        // Parse and validate structure
+        val parsed = JsonParser.parseString(requestJson).asJsonObject
+        assertThat(parsed.get("model").asString).isEqualTo("test-model")
+        assertThat(parsed.get("max_tokens").asInt).isEqualTo(1024)
+        assertThat(parsed.get("temperature").asDouble).isEqualTo(0.1)
+
+        val messages = parsed.getAsJsonArray("messages")
+        assertThat(messages.size()).isEqualTo(2)
+
+        // System message
+        val systemMsg = messages[0].asJsonObject
+        assertThat(systemMsg.get("role").asString).isEqualTo("system")
+        assertThat(systemMsg.get("content").asString).contains("screen_type")
+
+        // User message with image
+        val userMsg = messages[1].asJsonObject
+        assertThat(userMsg.get("role").asString).isEqualTo("user")
+        val content = userMsg.getAsJsonArray("content")
+        assertThat(content.size()).isEqualTo(2)
+
+        val textPart = content[0].asJsonObject
+        assertThat(textPart.get("type").asString).isEqualTo("text")
+
+        val imagePart = content[1].asJsonObject
+        assertThat(imagePart.get("type").asString).isEqualTo("image_url")
+        val imageUrl = imagePart.getAsJsonObject("image_url").get("url").asString
+        assertThat(imageUrl).contains("data:image/png;base64,")
+        assertThat(imageUrl).contains(fakeBase64)
+    }
+
+    /**
+     * Helper to call the private parseResponse method via reflection.
+     */
+    private fun parseResponseViaReflection(
+        responseBody: String,
+        model: String,
+        latencyMs: Long
+    ): ScreenIdentificationResult {
+        val service = OpenRouterLlmService(apiKey = "test-key")
+        val method = OpenRouterLlmService::class.java.getDeclaredMethod(
+            "parseResponse", String::class.java, String::class.java, Long::class.java
+        )
+        method.isAccessible = true
+        return method.invoke(service, responseBody, model, latencyMs) as ScreenIdentificationResult
+    }
+}

From 669baacdaf955970a8667d837f5b32d968fe0264 Mon Sep 17 00:00:00 2001
From: DW <29315038+DCPMA@users.noreply.github.com>
Date: Fri, 20 Mar 2026 23:03:01 +0000
Subject: [PATCH 5/6] refactor: Remove unused import and redundant dependency
 [PRL-276]

Clean up unused SerializedName import and remove redundant
kotlinx-coroutines-core dependency (already transitively available
via libautomata's api() dependency).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 scripts/build.gradle.kts                                        | 1 -
 .../fate_grand_automata/scripts/llm/OpenRouterLlmService.kt     | 2 --
 2 files changed, 3 deletions(-)

diff --git a/scripts/build.gradle.kts b/scripts/build.gradle.kts
index 7057760c8..57ba0f64b 100644
--- a/scripts/build.gradle.kts
+++ b/scripts/build.gradle.kts
@@ -17,7 +17,6 @@ dependencies {
     // LLM service dependencies
     implementation(libs.okhttp)
     implementation(libs.google.gson)
-    implementation(libs.kotlinx.coroutines.core)
 
     testImplementation(platform(libs.junit.bom)) {
         because("kotlin-test comes with conflicting junit versions")
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
index 2402d5f25..53836040e 100644
--- a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
@@ -1,9 +1,7 @@
 package io.github.fate_grand_automata.scripts.llm
 
 import com.google.gson.Gson
-import com.google.gson.JsonObject
 import com.google.gson.JsonParser
-import com.google.gson.annotations.SerializedName
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request

From 1e0bb58b7dc4536a660d594f7e149447909a9a6b Mon Sep 17 00:00:00 2001
From: DW <29315038+DCPMA@users.noreply.github.com>
Date: Fri, 20 Mar 2026 23:16:37 +0000
Subject: [PATCH 6/6] fix: address Copilot review comments on PR #1

- Wrap blocking OkHttp call in withContext(Dispatchers.IO)
- Use Response.use{} for proper resource cleanup
- Make markdown fence stripping regex more robust
- Pass original exception as cause in LlmServiceException
- Fix macOS-specific base64 -i flag for cross-platform compat
- Replace inline base64 arg with temp file to avoid ARG_MAX
- Remove unused test imports and declarations

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 llm-spike/run-spike.sh                        | 53 ++++++++++---------
 scripts/build.gradle.kts                      |  1 +
 .../scripts/llm/OpenRouterLlmService.kt       | 33 +++++++-----
 .../scripts/llm/LlmServiceTest.kt             |  4 --
 .../scripts/llm/OpenRouterLlmServiceTest.kt   |  4 --
 5 files changed, 49 insertions(+), 46 deletions(-)

diff --git a/llm-spike/run-spike.sh b/llm-spike/run-spike.sh
index 13146293f..cb4463a64 100755
--- a/llm-spike/run-spike.sh
+++ b/llm-spike/run-spike.sh
@@ -59,25 +59,35 @@ analyze_screenshot() {
 
     echo "  Analyzing with model: $model"
 
-    # Base64 encode the screenshot
-    local base64_data
-    base64_data=$(base64 -i "$screenshot_path" | tr -d '\n')
+    # Base64 encode the screenshot to a temp file (avoids ARG_MAX overflow for large screenshots)
+    # Uses portable base64 invocation (no flags) that works on both macOS and Linux
+    local base64_file
+    base64_file=$(mktemp)
+    base64 < "$screenshot_path" | tr -d '\n' > "$base64_file"
+    trap "rm -f '$base64_file'" RETURN
+
+    # Build the request JSON; Python reads the base64 file to avoid command-line size limits
+    local request_json
+    request_json=$(python3 - "$model" "$base64_file" <<'PYEOF'
+import json, sys
 
-    # Build the system prompt (JSON-escaped)
-    local system_prompt
-    system_prompt=$(python3 -c "
-import json
-prompt = '''You are an expert game screen analyzer for Fate/Grand Order (FGO), a mobile RPG game.
+model = sys.argv[1]
+base64_file = sys.argv[2]
+
+with open(base64_file) as f:
+    base64_data = f.read()
+
+system_prompt = """You are an expert game screen analyzer for Fate/Grand Order (FGO), a mobile RPG game.
 Your job is to identify the current game screen from a screenshot and provide structured information.
 
 You MUST respond with ONLY a valid JSON object (no markdown, no explanation outside JSON) matching this exact schema:
 
 {
-  \"screen_type\": \"<one of: HOME, QUEST_SELECT, EVENT, SUPPORT_SELECT, PARTY_SETUP, BATTLE, CARD_SELECT, QUEST_REWARD, BOND_RESULT, MASTER_EXP, SUMMON, PRESENT_BOX, SHOP, ENHANCEMENT, DIALOG, LOADING, LOGIN_REWARD, AP_REFILL, ERROR, UNKNOWN>\",
-  \"confidence\": <number from 0.0 to 1.0>,
-  \"description\": \"<brief description of what is currently shown on screen>\",
-  \"visible_elements\": [\"<list of UI elements visible on screen>\"],
-  \"suggested_actions\": [\"<list of actions a player could take on this screen>\"]
+  "screen_type": "<one of: HOME, QUEST_SELECT, EVENT, SUPPORT_SELECT, PARTY_SETUP, BATTLE, CARD_SELECT, QUEST_REWARD, BOND_RESULT, MASTER_EXP, SUMMON, PRESENT_BOX, SHOP, ENHANCEMENT, DIALOG, LOADING, LOGIN_REWARD, AP_REFILL, ERROR, UNKNOWN>",
+  "confidence": <number from 0.0 to 1.0>,
+  "description": "<brief description of what is currently shown on screen>",
+  "visible_elements": ["<list of UI elements visible on screen>"],
+  "suggested_actions": ["<list of actions a player could take on this screen>"]
 }
 
 Key screen identification rules:
@@ -97,20 +107,14 @@ Key screen identification rules:
 - LOADING: Loading screen with progress indicator or Now Loading text.
 
 Be precise. If you see battle UI elements (HP bars, skill icons, BATTLE text), it is BATTLE, not CARD_SELECT.
-If you see command cards for selection, it is CARD_SELECT.'''
-print(json.dumps(prompt))
-")
+If you see command cards for selection, it is CARD_SELECT."""
 
-    # Build the request JSON
-    local request_json
-    request_json=$(python3 -c "
-import json
 data = {
-    'model': '$model',
+    'model': model,
     'messages': [
         {
             'role': 'system',
-            'content': $system_prompt
+            'content': system_prompt
         },
         {
             'role': 'user',
@@ -122,7 +126,7 @@ data = {
                 {
                     'type': 'image_url',
                     'image_url': {
-                        'url': 'data:image/png;base64,$base64_data'
+                        'url': f'data:image/png;base64,{base64_data}'
                     }
                 }
             ]
@@ -132,7 +136,8 @@ data = {
     'temperature': 0.1
 }
 print(json.dumps(data))
-")
+PYEOF
+    )
 
     local result_file="$RESULTS_DIR/${screenshot_name}_${model//\//_}_${TIMESTAMP}.json"
 
diff --git a/scripts/build.gradle.kts b/scripts/build.gradle.kts
index 57ba0f64b..7057760c8 100644
--- a/scripts/build.gradle.kts
+++ b/scripts/build.gradle.kts
@@ -17,6 +17,7 @@ dependencies {
     // LLM service dependencies
     implementation(libs.okhttp)
     implementation(libs.google.gson)
+    implementation(libs.kotlinx.coroutines.core)
 
     testImplementation(platform(libs.junit.bom)) {
         because("kotlin-test comes with conflicting junit versions")
diff --git a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
index 53836040e..1b0f0de96 100644
--- a/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
+++ b/scripts/src/main/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmService.kt
@@ -2,6 +2,8 @@ package io.github.fate_grand_automata.scripts.llm
 
 import com.google.gson.Gson
 import com.google.gson.JsonParser
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -61,19 +63,22 @@ class OpenRouterLlmService(
 
         val timeMark = TimeSource.Monotonic.markNow()
 
-        val response = client.newCall(request).execute()
-        val latencyMs = timeMark.elapsedNow().inWholeMilliseconds
+        return withContext(Dispatchers.IO) {
+            client.newCall(request).execute().use { response ->
+                val latencyMs = timeMark.elapsedNow().inWholeMilliseconds
 
-        val responseBody = response.body?.string()
-            ?: throw LlmServiceException("Empty response body from OpenRouter")
+                val responseBody = response.body?.string()
+                    ?: throw LlmServiceException("Empty response body from OpenRouter")
 
-        if (!response.isSuccessful) {
-            throw LlmServiceException(
-                "OpenRouter API error ${response.code}: $responseBody"
-            )
-        }
+                if (!response.isSuccessful) {
+                    throw LlmServiceException(
+                        "OpenRouter API error ${response.code}: $responseBody"
+                    )
+                }
 
-        return parseResponse(responseBody, model, latencyMs)
+                parseResponse(responseBody, model, latencyMs)
+            }
+        }
     }
 
     private fun buildRequestBody(screenshotBase64: String, model: String): String {
@@ -139,17 +144,17 @@ class OpenRouterLlmService(
             ?: throw LlmServiceException("No message content in response: $responseBody")
 
         // Parse the JSON from the LLM's response
-        // Strip markdown code fences if present
+        // Strip markdown code fences if present (handles ```json, ```JSON, ``` with optional whitespace)
         val cleanedContent = messageContent
-            .replace(Regex("^```json\\s*", RegexOption.MULTILINE), "")
-            .replace(Regex("^```\\s*$", RegexOption.MULTILINE), "")
+            .replace(Regex("^\\s*```[a-zA-Z]*\\s*$", RegexOption.MULTILINE), "")
             .trim()
 
         val resultJson = try {
             JsonParser.parseString(cleanedContent).asJsonObject
         } catch (e: Exception) {
             throw LlmServiceException(
-                "Failed to parse LLM JSON response: ${e.message}\nRaw: $messageContent"
+                "Failed to parse LLM JSON response: ${e.message}\nRaw: $messageContent",
+                cause = e
             )
         }
 
diff --git a/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt
index 26ccf1f8c..6dbca79c2 100644
--- a/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt
+++ b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/LlmServiceTest.kt
@@ -2,12 +2,8 @@ package io.github.fate_grand_automata.scripts.llm
 
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import assertk.assertions.isGreaterThan
 import assertk.assertions.isNotEmpty
 import assertk.assertions.isNotNull
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.verify
 import kotlin.test.Test
 
 /**
diff --git a/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt
index 01857aeb8..1b8163362 100644
--- a/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt
+++ b/scripts/src/test/java/io/github/fate_grand_automata/scripts/llm/OpenRouterLlmServiceTest.kt
@@ -3,11 +3,9 @@ package io.github.fate_grand_automata.scripts.llm
 import assertk.assertThat
 import assertk.assertions.contains
 import assertk.assertions.isEqualTo
-import assertk.assertions.isGreaterThan
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotEmpty
 import assertk.assertions.isNotNull
-import com.google.gson.Gson
 import com.google.gson.JsonParser
 import java.lang.reflect.InvocationTargetException
 import kotlin.test.Test
@@ -21,8 +19,6 @@ import kotlin.test.assertFailsWith
  */
 class OpenRouterLlmServiceTest {
 
-    private val gson = Gson()
-
     @Test
     fun `parseResponse correctly handles a valid battle screen response`() {
         val responseBody = """