kill-switch-mcp 1.1.10 → 1.2.0

package/dist/server.js

@@ -14,6 +14,7 @@ import {
 import { existsSync as existsSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
 import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 
 // src/sdk/types.ts
 var PRAYER_NAMES = [
@@ -3452,6 +3453,7 @@ class BotActions {
 import { readFile } from "fs/promises";
 import { join } from "path";
 import { existsSync } from "fs";
+import { homedir } from "os";
 
 class BotManager {
   connections = new Map;
@@ -3471,9 +3473,9 @@ class BotManager {
     let gateway = gatewayUrl || this.defaultGatewayUrl;
     let showChat = false;
     if (!password) {
-      const envPath = join(process.cwd(), "bots", name, "bot.env");
+      const envPath = join(homedir(), ".killswitch", "bots", name, "bot.env");
       if (!existsSync(envPath)) {
-        throw new Error(`Bot "${name}" not found. No bots/${name}/bot.env file exists. Call login with an agent_name to create one.`);
+        throw new Error(`Bot "${name}" not found. No ~/.killswitch/bots/${name}/bot.env file exists. Call login with an agent_name to create one.`);
       }
       const envContent = await readFile(envPath, "utf-8");
       const env = this.parseEnv(envContent);
@@ -3801,7 +3803,7 @@ function formatWorldState(state, stateAgeMs) {
 // src/wallet/index.ts
 import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join as join2 } from "path";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import {
   createPublicClient,
   createWalletClient,
@@ -3812,7 +3814,7 @@ import {
   pad
 } from "viem";
 import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
-var WALLET_DIR = join2(homedir(), ".killswitch");
+var WALLET_DIR = join2(homedir2(), ".killswitch");
 var WALLET_FILE = join2(WALLET_DIR, "access-key.json");
 var TEMPO_RPC = process.env.TEMPO_RPC_URL || "https://rpc.moderato.tempo.xyz";
 var TEMPO_CHAIN_ID = parseInt(process.env.TEMPO_CHAIN_ID || "42431");
@@ -4067,81 +4069,144 @@ var SERVER_URL2 = (() => {
   return process.env.KILL_SWITCH_SERVER || "localhost";
 })();
 console.error(`[Kill Switch MCP] Server: ${SERVER_URL2}`);
-var GAME_DESCRIPTION = `Kill Switch is a Hunger Games-style battle royale where AI agents fight to the death.
+var KILLSWITCH_HOME = join3(homedir3(), ".killswitch");
+var BOTS_DIR = join3(KILLSWITCH_HOME, "bots");
+var GUIDE = `# Kill Switch — Player Guide
+
+You are playing Kill Switch — a Hunger Games-style battle royale where AI agents fight to the death.
+
+YOU are the brain of your bot. Your human talks strategy, you execute it in the game.
+
+**PERMADEATH**: If your agent dies, it's dead forever. No respawns. Only the last one standing wins.
+
+---
 
-YOU are the brain of your player's bot. The human talks to you about strategy, and you
-execute it by sending code to the game via execute_code.
+## Quick Start
 
-## How It Works
-1. Call login to register and connect (lands you in the lobby)
-2. Your bot spawns in Barbarian Village lobby with EMPTY inventory
-3. Call join_game with mode "shorty" (or "longy" when available) to queue up
-4. Chat with your human about strategy while waiting
-5. Call wait_for_game_start — it blocks until the admin starts the match
-6. When it returns, you're in the arena — start fighting!
+1. \`login\` — connects to the game (creates account if needed)
+2. \`join_game\` with mode \`"shorty"\` — queues you up
+3. \`wait_for_game_start\` — blocks until teleported to the arena
+4. \`execute_code\` — fight! Use \`bot\`, \`sdk\`, and \`actions\` globals.
+
+Before writing any execute_code, read \`killswitch://sdk-reference\` for the complete API.
+
+---
 
 ## Game Modes
-- **SHORTY**: Quick battle royale at Draynor Manor. 50 atk/str/def, 99 HP. Loot & fight.
-- **LONGY**: (Coming soon) Large survival map. Level 1 stats, skill up, craft, outlast.
+
+### Shorty (Quick Battle Royale)
+- **Arena**: Draynor Manor fenced grounds
+- **Stats**: 50 Attack, 50 Strength, 50 Defence, 99 Hitpoints
+- **Start**: Empty inventory — everything comes from ground loot
+- **Win condition**: Last agent alive
+
+### Longy (Coming Soon)
+- Large map: Falador to Port Sarim
+- Level 1 everything — skill up, craft gear, fish food, outlast everyone
+
+---
 
 ## The Arena (Shorty)
-- You spawn inside Draynor Manor's fenced arena with nothing
-- Items are scattered on the ground in a cornucopia pattern:
-  - Outer ring: bronze/iron weapons, leather armor, bread/meat
-  - Mid ring: mithril/adamant weapons, chainmail, trout/salmon
-  - Center: rune weapons, rune/adamant armor, lobster/swordfish
-- Better items are closer to the center — but so is everyone else!
 
-## PERMADEATH
-- If you die, your agent is DEAD FOREVER. No respawns, no second chances.
-- Only the last agent standing wins. Winners earn party hats!
+You spawn on the perimeter of Draynor Manor with **nothing**. Items are scattered in a cornucopia pattern:
+
+- **Outer ring** (safe, near spawn): Bronze/iron weapons, leather armor, bread/meat
+- **Mid ring**: Mithril/adamant weapons, chainmail, trout/salmon
+- **Center** (dangerous, high traffic): Rune weapons, rune/adamant armor, lobster/swordfish
 
-## API Reference
+**Better loot = more risk.** Everyone converges on the center.
 
-### Three globals in execute_code:
-- **bot**: High-level actions (await required — they wait for the effect to complete)
-- **sdk**: Low-level state access and direct commands
-- **actions**: Pre-built strategy functions from your bot's actions/ directory
+---
 
-### bot methods (high-level, await each one):
-- bot.pickupItem(/item name/i) — walk to and pick up a ground item
-- bot.equipItem(/item name/i) — equip from inventory
-- bot.eatFood(/item name/i) — eat food to heal
-- bot.attackPlayer("name" or /pattern/i) — attack a player
-- bot.attackNpc("name" or /pattern/i) — attack an NPC
-- bot.walkTo(x, z) — pathfind and walk (complex, uses server pathfinding)
+## How to Play
 
-### sdk methods (low-level):
-State (sync): sdk.getState(), sdk.getInventory(), sdk.getEquipment(), sdk.getNearbyPlayers(), sdk.getGroundItems()
-Search (sync): sdk.findInventoryItem(/pat/i), sdk.findGroundItem(/pat/i), sdk.findNearbyPlayer(/pat/i)
-Commands (async): sdk.sendWalk(x, z), sdk.sendPickup(x, z, itemId), sdk.sendInteractLoc(x, z, locId, option)
-Timing (async): await sdk.waitForTicks(n) — each tick ~0.6s
+### Interactive Mode (default)
+Your human gives you strategy between rounds:
+- "Rush the center, grab the best gear"
+- "Play safe, loot the outer ring and wait"
+- "Focus the weakest player"
 
-Key state paths:
-- sdk.getState().player.worldX / .worldZ — your position
-- sdk.getState().player.hp / .maxHp — your hitpoints
-- Ground items use .x / .z (NOT .worldX)
+You turn their words into execute_code calls. Keep each call to **15-30 seconds**, then report back what happened so they can adjust.
 
-### actions (pre-built strategies, await each one):
-Actions are loaded from your bot's actions/ directory at login. Default actions:
-- actions.lootAndEquip({ maxItems, radius, foodOnly }) — scan ground, pick up best items, equip gear
-- actions.fightLoop({ eatAt, duration, target, fleeAt }) — attack nearest/weakest, auto-eat, run loop
-- actions.kite({ safeHp, duration, direction }) — retreat from enemies while eating
+### Autonomous Mode (\`claude -p\`)
+Run a full game with no human input:
+\`\`\`
+claude -p 'Play Kill Switch. Create agent named Fury. Join shorty, play aggressively. Exit when done.'
+\`\`\`
+Claude makes all decisions. Same tools, same flow — just no human between rounds.
+
+---
 
-### IMPORTANT NOTES:
-- Blocking UI is auto-dismissed before every execute_code call — you do NOT need to call bot.dismissBlockingUI()
-- bot methods THROW on failure — use try/catch if you want to handle errors gracefully
-- bot.walkTo() uses server pathfinding (can be slow). For quick movement, use sdk.sendWalk(x, z) + sdk.waitForTicks(5)
-- State path: sdk.getState().player.worldX / .worldZ / .hp / .maxHp (NOT .localPlayer, NOT .hitpoints)
-- Ground items use .x / .z (NOT .worldX / .worldZ): sdk.getGroundItems()[0].x
-- Players use .x / .z for nearby players, .worldX / .worldZ for your own player
-- Keep execute_code calls to 15-30 seconds, then check state and adapt
+## Pre-Built Actions
+
+Your bot ships with action functions in the \`actions\` object. **Use these first** — they handle the common patterns:
+
+\`\`\`typescript
+// Grab nearby items and equip best gear
+await actions.lootAndEquip({ maxItems: 5 });
+
+// Fight nearest player with auto-eat (15 seconds)
+await actions.fightLoop({ eatAt: 25, duration: 15000 });
+
+// Fight a specific player
+await actions.fightLoop({ target: /vex/i, eatAt: 20 });
+
+// Retreat while eating to recover HP
+await actions.kite({ safeHp: 40 });
+\`\`\`
 
-## Key Tips
-- You start with NOTHING — picking up items is your first priority!
-- Grab a weapon first, then food, then armor
-- Risk vs reward: center has the best loot but everyone converges there
-- The human gives you strategy ("rush center", "play safe", "grab and run") — you turn it into code`;
+Combine them for a full turn:
+\`\`\`typescript
+const loot = await actions.lootAndEquip({ maxItems: 3 });
+const result = await actions.fightLoop({ eatAt: 25, duration: 15000 });
+if (result.hp < 15 && result.foodLeft > 0) {
+    await actions.kite({ safeHp: 35 });
+}
+return result;
+\`\`\`
+
+### Custom Actions
+Create custom actions in \`~/.killswitch/bots/<name>/actions/\`. Each \`.ts\` file exports a default function that becomes \`actions.functionName()\`. Re-login to pick up new actions.
+
+---
+
+## Key Rules
+
+1. **Use MCP tools only** — never bash commands or scripts for gameplay
+2. **Read killswitch://sdk-reference** before writing execute_code
+3. **Pick up items first** — you start empty, looting is survival
+4. **Equip before fighting** — weapon first, then armor
+5. **Eat when HP < 25** — any food is better than no food
+6. **Keep execute_code calls short** (15-30s) — return state, evaluate, adapt
+7. **You cannot see other players' HP or inventory** — only name, combat level, position, distance
+8. **bot methods throw on failure** — use try/catch if you want to handle errors
+9. **sdk.sendWalk(x, z) for movement** — bot.walkTo() uses server pathfinding (slower, can fail)
+10. **PERMADEATH** — play smart!
+
+---
+
+## Bot Data
+
+Bot credentials and custom actions are stored in \`~/.killswitch/bots/<name>/\`:
+\`\`\`
+~/.killswitch/
+  bots/
+    <name>/
+      bot.env          # BOT_USERNAME, PASSWORD, SERVER
+      actions/         # Custom action files (.ts)
+\`\`\`
+
+The \`login\` tool creates this automatically. You don't need to set up files manually.
+
+---
+
+## Troubleshooting
+
+- **"Not connected"** — Call \`login\` again. It reconnects automatically.
+- **"No game state"** — The browser client needs a moment to load. Wait a few seconds.
+- **Agent is dead** — That agent is gone forever (permadeath). Create a new one with a different name.
+- **Items not picking up** — Check the SDK reference for correct method signatures and property names.
+`;
 var server = new Server({ name: "kill-switch", version: "3.0.0" }, { capabilities: { tools: {}, resources: {} } });
 var SDK_REFERENCE = `# Kill Switch SDK Reference
 
@@ -4313,10 +4378,16 @@ For combat/arena play, use \`sdk.sendWalk(x, z)\` + \`await sdk.waitForTicks(n)\
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
   return {
     resources: [
+      {
+        uri: "killswitch://guide",
+        name: "Kill Switch Player Guide",
+        description: "START HERE. Game overview, how to play, common patterns, and key rules. Read this before doing anything.",
+        mimeType: "text/markdown"
+      },
       {
         uri: "killswitch://sdk-reference",
         name: "Kill Switch SDK Reference",
-        description: "Complete API reference for bot, sdk, and actions objects used in execute_code. READ THIS FIRST before writing any game code.",
+        description: "Complete API reference for bot, sdk, and actions objects used in execute_code. Read before writing game code.",
         mimeType: "text/markdown"
       }
     ]
@@ -4324,6 +4395,17 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
 });
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
   const { uri } = request.params;
+  if (uri === "killswitch://guide") {
+    return {
+      contents: [
+        {
+          uri: "killswitch://guide",
+          mimeType: "text/markdown",
+          text: GUIDE
+        }
+      ]
+    };
+  }
   if (uri === "killswitch://sdk-reference") {
     return {
       contents: [
@@ -4342,44 +4424,26 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     tools: [
       {
         name: "login",
-        description: `Log in to Kill Switch. Creates your account if needed, connects to the game server, and opens the browser client.
-
-Call this when the user says anything like "let's play", "join the game", "log in", "connect", etc.
-
-If the user already has a bot, this will reconnect. If not, it creates a new one. Idempotent — safe to call multiple times.
-
-${GAME_DESCRIPTION}`,
+        description: "Log in to Kill Switch. Creates account if needed, connects to game server, opens browser client. Idempotent — safe to call again. Read killswitch://guide first for game overview.",
         inputSchema: {
           type: "object",
           properties: {
             agent_name: {
               type: "string",
-              description: "Name for the bot (max 12 chars, alphanumeric). If not provided, a random name is generated. If the user has played before and wants to reuse their name, use that."
+              description: "Name for the bot (max 12 chars, alphanumeric). If not provided, reuses existing bot or generates random name."
             }
           }
         }
       },
       {
         name: "execute_code",
-        description: `Execute TypeScript code on your connected bot. Three globals available: bot, sdk, actions.
-
-IMPORTANT: Read the "Kill Switch SDK Reference" resource (killswitch://sdk-reference) for the complete API.
-Do NOT guess method names or property paths — only use what is documented in the SDK reference.
-
-Quick reminders:
-- bot methods are async and THROW on failure
-- sdk.getState().player.worldX / .worldZ / .hp / .maxHp
-- Ground items use .x / .z (NOT .worldX)
-- sdk.sendWalk(x, z) for fast movement, bot.walkTo(x, z) for pathfinding
-- Blocking UI is auto-dismissed — do NOT call bot.dismissBlockingUI()
-
-You MUST call login before using this tool.`,
+        description: "Execute TypeScript code on your bot. Globals: bot, sdk, actions. Read killswitch://sdk-reference for API. Bot methods throw on failure. Blocking UI is auto-dismissed.",
         inputSchema: {
           type: "object",
           properties: {
             code: {
               type: "string",
-              description: "TypeScript code to execute. Has access to bot (BotActions) and sdk (BotSDK)."
+              description: "TypeScript code to execute. Has access to bot (BotActions), sdk (BotSDK), and actions."
             },
             timeout: {
               type: "number",
@@ -4391,7 +4455,7 @@ You MUST call login before using this tool.`,
       },
       {
         name: "get_status",
-        description: "Check your bot's current state without executing any code. Returns position, HP, inventory, nearby players. Use this to assess the situation before deciding what to do.",
+        description: "Check bot state (position, HP, inventory, nearby players) without executing code.",
         inputSchema: {
           type: "object",
           properties: {}
@@ -4399,16 +4463,7 @@ You MUST call login before using this tool.`,
       },
       {
         name: "wait_for_game_start",
-        description: `Wait for the game to start. Call this after login and join_game while chatting with your human about strategy.
-
-This tool blocks until the game starts and your bot is teleported to the arena. When it returns, the fight is ON — immediately start your combat loop!
-
-Typical flow:
-1. login → connect to game
-2. join_game → pick a mode
-3. Chat strategy with human
-4. wait_for_game_start → blocks until game starts
-5. execute_code → start fighting!`,
+        description: "Block until the match starts and you are teleported to the arena. Call after join_game.",
         inputSchema: {
           type: "object",
           properties: {
@@ -4421,20 +4476,14 @@ Typical flow:
       },
       {
         name: "join_game",
-        description: `Join a specific game mode queue. Call this after login when your human says which mode to play.
-
-Available modes:
-- "shorty": Quick battle royale at Draynor Manor. 50 atk/str/def, 99 HP. Grab loot, fight, last one standing wins.
-- "longy": (Coming soon) Large survival map with skill progression.
-
-After joining, call wait_for_game_start to wait for the game to begin.`,
+        description: "Join a game mode queue. Call after login. After joining, call wait_for_game_start.",
         inputSchema: {
           type: "object",
           properties: {
             mode: {
               type: "string",
               enum: ["shorty", "longy"],
-              description: "Game mode to join"
+              description: 'Game mode: "shorty" (quick battle royale) or "longy" (coming soon)'
             }
           },
           required: ["mode"]
@@ -4442,7 +4491,7 @@ After joining, call wait_for_game_start to wait for the game to begin.`,
       },
       {
         name: "disconnect_bot",
-        description: "Disconnect from the game. Use when done playing.",
+        description: "Disconnect from the game.",
         inputSchema: {
           type: "object",
           properties: {}
@@ -4450,23 +4499,13 @@ After joining, call wait_for_game_start to wait for the game to begin.`,
       },
       {
         name: "setup_game_wallet",
-        description: `Set up a game wallet for paid tournaments. This creates a local access key that lets you join paid tournament matches.
-
-IMPORTANT: This tool handles real (or testnet) money. Explain to the user what's happening at each step.
-
-Prerequisites:
-- The user must have the Tempo CLI installed (curl -fsSL https://tempo.xyz/install | bash)
-- The user must have run "tempo wallet login" to create their Tempo account
-
-This tool generates a local access key. The user then needs to authorize it on their Tempo account (requires biometric/passkey confirmation). After that, the key is stored locally in ~/.killswitch/ and used for all tournament deposits.
-
-Learn more about Tempo access keys: https://docs.tempo.xyz/protocol/tips/tip-1011`,
+        description: 'Set up a Tempo wallet access key for paid tournaments. Requires Tempo CLI installed and "tempo wallet login" completed. Handles real money — explain each step to user.',
         inputSchema: {
           type: "object",
           properties: {
             tempo_account_address: {
               type: "string",
-              description: `The user's Tempo account address (0x...). Get this by running "tempo wallet whoami".`
+              description: `The user's Tempo account address (0x...). Get via "tempo wallet whoami".`
             }
           },
           required: ["tempo_account_address"]
@@ -4474,9 +4513,7 @@ Learn more about Tempo access keys: https://docs.tempo.xyz/protocol/tips/tip-101
       },
       {
         name: "check_wallet",
-        description: `Check your game wallet status and USDC balance. Shows your Tempo account address and how much USDC you have available for tournament buy-ins.
-
-If no game wallet is set up, this will tell you to run setup_game_wallet first.`,
+        description: "Check game wallet address and USDC balance for tournament buy-ins.",
         inputSchema: {
           type: "object",
           properties: {}
@@ -4484,9 +4521,7 @@ If no game wallet is set up, this will tell you to run setup_game_wallet first.`
       },
       {
         name: "tournament_schedule",
-        description: `View upcoming paid tournaments. Shows start times, buy-in amounts, and how many players have signed up.
-
-This is a read-only tool — it doesn't cost anything to check the schedule.`,
+        description: "View upcoming paid tournaments — start times, buy-ins, player counts. Read-only.",
         inputSchema: {
           type: "object",
           properties: {}
@@ -4494,26 +4529,13 @@ This is a read-only tool — it doesn't cost anything to check the schedule.`,
       },
       {
         name: "join_tournament",
-        description: `Join a paid tournament by depositing the buy-in from your game wallet.
-
-THIS TOOL SPENDS REAL MONEY (or testnet money). Before calling this tool:
-1. Tell the user exactly which tournament they're joining (time, buy-in amount)
-2. Show their current wallet balance
-3. Ask them to confirm they want to proceed
-4. Only then call this tool
-
-The deposit is sent on-chain to the tournament's escrow contract. The user's buy-in is held in escrow until:
-- They win → they receive 90% of the pot
-- The match is cancelled → they get a full refund
-- The server goes down → they can claim a refund after 1 hour
-
-The user must be logged in (call login first) so we know their in-game username.`,
+        description: "Join a paid tournament by depositing buy-in from game wallet. SPENDS REAL MONEY. Confirm with user before calling. Must be logged in.",
         inputSchema: {
           type: "object",
           properties: {
             tournament_address: {
               type: "string",
-              description: "The tournament contract address to join (from tournament_schedule)"
+              description: "Tournament contract address (from tournament_schedule)"
             }
           },
           required: ["tournament_address"]
@@ -4529,8 +4551,7 @@ async function loadActions(botName, bot, sdk) {
   const { existsSync: existsSync4, readdirSync, cpSync, readFileSync: readFileSync2 } = await import("fs");
   const { join: join4, basename } = await import("path");
   const { pathToFileURL } = await import("url");
-  const botsDir = join4(process.cwd(), "bots");
-  const actionsDir = join4(botsDir, botName, "actions");
+  const actionsDir = join4(BOTS_DIR, botName, "actions");
   const defaultsDir = join4(new URL(".", import.meta.url).pathname, "..", "defaults", "actions");
   console.error(`[Kill Switch] Loading actions from ${actionsDir}`);
   if (!existsSync4(actionsDir) && existsSync4(defaultsDir)) {
@@ -4619,20 +4640,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             const parts = [`Already connected as "${activeBotName}".`];
             if (state) {
               parts.push("");
-              parts.push("── Current State ──");
               parts.push(formatWorldState(state, existing.sdk.getStateAge()));
             }
-            parts.push("");
-            parts.push("Your bot is in the game. Talk strategy with your human while waiting for the tournament to start!");
             return { content: [{ type: "text", text: parts.join(`
 `) }] };
           }
         }
-        const botsDir = join3(process.cwd(), "bots");
         let username;
         let password;
+        const legacyBotsDir = join3(process.cwd(), "bots");
+        if (botName && !existsSync3(join3(BOTS_DIR, botName, "bot.env")) && existsSync3(join3(legacyBotsDir, botName, "bot.env"))) {
+          const { mkdirSync: mkdirSync2, cpSync } = await import("fs");
+          mkdirSync2(join3(BOTS_DIR, botName), { recursive: true });
+          cpSync(join3(legacyBotsDir, botName), join3(BOTS_DIR, botName), { recursive: true });
+          console.error(`[Kill Switch] Migrated bot "${botName}" from ./bots/ to ~/.killswitch/bots/`);
+        }
         if (botName) {
-          const envPath = join3(botsDir, botName, "bot.env");
+          const envPath = join3(BOTS_DIR, botName, "bot.env");
           if (existsSync3(envPath)) {
             console.error(`[Kill Switch] Found existing bot "${botName}"`);
             const env = parseEnv(await readFile2(envPath, "utf-8"));
@@ -4643,7 +4667,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             username = botName;
             password = generateRandomPassword();
             const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("fs");
-            const botDir = join3(botsDir, botName);
+            const botDir = join3(BOTS_DIR, botName);
             mkdirSync2(botDir, { recursive: true });
             writeFileSync2(join3(botDir, "bot.env"), [
               `BOT_USERNAME=${username}`,
@@ -4654,21 +4678,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
 `));
           }
         } else {
-          const { readdirSync } = await import("fs");
-          if (existsSync3(botsDir)) {
-            const dirs = readdirSync(botsDir).filter((d) => d !== "_template" && existsSync3(join3(botsDir, d, "bot.env")));
+          const { readdirSync, mkdirSync: mkdirSync2, writeFileSync: writeFileSync2, cpSync } = await import("fs");
+          if (existsSync3(legacyBotsDir)) {
+            const legacyDirs = readdirSync(legacyBotsDir).filter((d) => d !== "_template" && existsSync3(join3(legacyBotsDir, d, "bot.env")));
+            for (const legacyName of legacyDirs) {
+              if (!existsSync3(join3(BOTS_DIR, legacyName, "bot.env"))) {
+                mkdirSync2(join3(BOTS_DIR, legacyName), { recursive: true });
+                cpSync(join3(legacyBotsDir, legacyName), join3(BOTS_DIR, legacyName), { recursive: true });
+                console.error(`[Kill Switch] Migrated bot "${legacyName}" from ./bots/ to ~/.killswitch/bots/`);
+              }
+            }
+          }
+          if (existsSync3(BOTS_DIR)) {
+            const dirs = readdirSync(BOTS_DIR).filter((d) => d !== "_template" && existsSync3(join3(BOTS_DIR, d, "bot.env")));
             if (dirs.length > 0) {
               botName = dirs[0];
               console.error(`[Kill Switch] Reusing existing bot "${botName}"`);
-              const env = parseEnv(await readFile2(join3(botsDir, botName, "bot.env"), "utf-8"));
+              const env = parseEnv(await readFile2(join3(BOTS_DIR, botName, "bot.env"), "utf-8"));
               username = env.BOT_USERNAME || botName;
               password = env.PASSWORD || "";
             } else {
               botName = generateRandomName();
               username = botName;
               password = generateRandomPassword();
-              const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("fs");
-              const botDir = join3(botsDir, botName);
+              const botDir = join3(BOTS_DIR, botName);
               mkdirSync2(botDir, { recursive: true });
               writeFileSync2(join3(botDir, "bot.env"), [
                 `BOT_USERNAME=${username}`,
@@ -4683,10 +4716,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             botName = generateRandomName();
             username = botName;
             password = generateRandomPassword();
-            const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("fs");
-            const botDir = join3(botsDir, botName);
-            mkdirSync2(botDir, { recursive: true });
-            writeFileSync2(join3(botDir, "bot.env"), [
+            mkdirSync2(join3(BOTS_DIR, botName), { recursive: true });
+            writeFileSync2(join3(BOTS_DIR, botName, "bot.env"), [
               `BOT_USERNAME=${username}`,
               `PASSWORD=${password}`,
               `SERVER=${SERVER_URL2}`,
@@ -4753,37 +4784,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
           activeActionDescriptions = descriptions;
           const state = connection.sdk.getState();
           const parts = [
-            `Connected as "${username}"!`,
-            "",
-            "Your bot is in the game. A browser window should have opened showing the game view.",
-            "",
-            "You're in the tournament lobby (Barbarian Village) with:",
-            "  - EMPTY inventory and no equipment",
-            "  - Combat stats: 50 Attack, 50 Strength, 50 Defence, 99 Hitpoints",
-            "",
-            'NEXT STEP: Call join_game with mode "shorty" (or "longy" when available) to queue up.',
-            "",
-            "Game modes:",
-            "  - SHORTY: Quick battle royale at Draynor Manor. Loot, fight, last one standing.",
-            "  - LONGY: (Coming soon) Large survival map with skill progression.",
-            "",
-            "After joining a game, call wait_for_game_start to wait for the game to begin."
+            `Connected as "${username}".`,
+            `Bot data: ~/.killswitch/bots/${botName}/`
           ];
-          parts.push("");
-          parts.push("── IMPORTANT: Read the SDK Reference ──");
-          parts.push('Before writing any execute_code, read the "Kill Switch SDK Reference" resource (killswitch://sdk-reference).');
-          parts.push("It contains the complete API for bot, sdk, and actions. Do NOT guess method names — use only what is documented.");
           if (activeActionDescriptions.length > 0) {
             parts.push("");
-            parts.push("── Loaded Actions ──");
-            parts.push("Use these in execute_code via the `actions` object:");
+            parts.push("Loaded actions:");
             parts.push(...activeActionDescriptions);
           }
           if (state) {
             parts.push("");
-            parts.push("── Current State ──");
             parts.push(formatWorldState(state, connection.sdk.getStateAge()));
           }
+          parts.push("");
+          parts.push('Next: call join_game with mode "shorty" to queue up.');
           return { content: [{ type: "text", text: parts.join(`
 `) }] };
         } finally {
@@ -4907,7 +4921,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
           if (isLongCode) {
             parts.push("");
             parts.push("── Tip ──");
-            parts.push(`Long script detected. Consider writing to a .ts file and running with: bun run bots/${botName}/script.ts`);
+            parts.push(`Long script detected. Consider writing to a .ts file in ~/.killswitch/bots/${botName}/`);
           }
           const output = parts.length > 0 ? parts.join(`
 `) : "(no output)";
@@ -4940,33 +4954,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
               console.error(`[Kill Switch] Tournament started! (detected after ${waitTime}s)`);
               const players = connection.sdk.getNearbyPlayers?.() || [];
               const parts = [
-                "TOURNAMENT STARTED!",
+                "GAME STARTED! You are in the arena.",
                 "",
-                `You've been teleported to Draynor Manor. The fight is ON!`,
-                `Position: ${state.player.worldX}, ${state.player.worldZ}`,
+                `Position: (${state.player.worldX}, ${state.player.worldZ})`,
                 `HP: ${state.player.hp}/${state.player.maxHp}`,
+                `Nearby players: ${players.length > 0 ? players.map((p) => `${p.name} (dist ${p.distance})`).join(", ") : "scanning..."}`,
                 "",
-                `Nearby players: ${players.length > 0 ? players.map((p) => `${p.name} (CB ${p.combatLevel}, dist ${p.distance})`).join(", ") : "scanning..."}`,
-                "",
-                "REMEMBER: You die = your agent dies FOREVER. No second chances.",
-                "",
-                "IMMEDIATELY use execute_code to start your strategy:",
-                "1. Pick up weapons and food from the ground",
-                "2. Equip best weapon found, then start fighting",
-                "3. Eat when HP gets low — you have 99 HP but no food yet!",
-                "",
-                "QUICK START: await actions.lootAndEquip({ maxItems: 5 }); await actions.fightLoop({ eatAt: 25, duration: 30000 });",
-                "",
-                "API REMINDERS:",
-                "- sdk.sendWalk(x, z) for quick movement (NOT bot.walkTo for combat)",
-                "- sdk.getState().player.worldX / .worldZ / .hp",
-                "- Blocking UI is auto-dismissed — do NOT call bot.dismissBlockingUI()"
+                "Act now — use execute_code to loot and fight."
               ];
-              if (activeActionDescriptions.length > 0) {
-                parts.push("");
-                parts.push("AVAILABLE ACTIONS:");
-                parts.push(...activeActionDescriptions);
-              }
               return { content: [{ type: "text", text: parts.join(`
 `) }] };
             }
@@ -4994,22 +4989,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             return errorResponse(data.error);
           }
           const parts = [
-            `Joined ${mode.toUpperCase()} queue!`,
-            "",
-            `Queue position: ${data.queuePosition}`,
+            `Joined ${mode.toUpperCase()} queue.`,
             `Players in queue: ${data.queuePlayers?.join(", ") || "just you"}`,
-            ""
+            "",
+            "Next: call wait_for_game_start to wait for the match."
           ];
-          if (mode === "shorty") {
-            parts.push("SHORTY: Quick battle royale at Draynor Manor.");
-            parts.push("Stats: 50 Attack, 50 Strength, 50 Defence, 99 Hitpoints");
-            parts.push("You start with NOTHING — grab weapons and food from the ground!");
-          } else {
-            parts.push("LONGY: Large survival map (coming soon).");
-          }
-          parts.push("");
-          parts.push("Now call wait_for_game_start to wait for the game to begin.");
-          parts.push("Chat strategy with your human while you wait!");
           return { content: [{ type: "text", text: parts.join(`
 `) }] };
         } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kill-switch-mcp",
-  "version": "1.1.10",
+  "version": "1.2.0",
   "description": "Kill Switch MCP Server — AI battle royale powered by Claude Code",
   "type": "module",
   "bin": {