v12.0: Fix spam kick loop - rate limited /setblock, shelter with door, shelter cache, smart starter debounce

bot.js

@@ -1,34 +1,36 @@
 /**
  * ============================================
- * bot.js — Zelin Minecraft Agent v10.0
+ * bot.js — Zelin Minecraft Agent v12.0
  * ============================================
- * CRITICAL FIXES from v9.0:
+ * CRITICAL FIXES from v11.0:
  *
- *  1. RAW PACKET NaN INTERCEPTION:
- *     - Intercept position packets BEFORE mineflayer physics processes them
- *     - Use bot._client.on('position') to catch NaN packets and substitute last good pos
- *     - This prevents NaN from ever entering the physics simulation
+ *  1. SPAM KICK FIX — Rate limit ALL /setblock commands:
+ *     - 600ms delay between EVERY /setblock (Paper spam threshold ~2 cmd/s)
+ *     - Shelter build uses throttled command queue
+ *     - On spam kick: 30s reconnect delay + skip shelter rebuild
  *
- *  2. keepInventory GAME RULE:
- *     - Set /gamerule keepInventory true on first spawn
- *     - Bot keeps items on death — stops death spiral
+ *  2. SHELTER WITH DOOR:
+ *     - Leave one wall block open as door at feet level
+ *     - Bot can enter/exit shelter freely
  *
- *  3. /setblock SHELTER BUILDING:
- *     - Bot has OP — use /setblock commands instead of placeBlock
- *     - No positioning/facing issues, 100% reliable
+ *  3. SHELTER CACHE:
+ *     - Remember shelter position, don't rebuild if one exists
+ *     - Check if shelter blocks still present before building
  *
- *  4. STARTER ITEMS ON EVERY RESPAWN:
- *     - Give items on respawn (not just first spawn)
- *     - Ensures bot always has tools even if keepInventory somehow fails
+ *  4. STARTER ITEMS SMART DEBOUNCE:
+ *     - Only give items bot actually needs
+ *     - Don't re-give on every reconnect after spam kick
+ *     - Track last give time, 60s cooldown
  *
- *  5. POSITION RESYNC AFTER NaN FIX:
- *     - After restoring from NaN, send position update to server
- *     - Prevents physics desync loop
+ *  5. ANTI-REPEAT FIX:
+ *     - Lower threshold from 4 to 3
+ *     - Include 'build' in night alternatives
+ *     - Don't force 'build' if shelter already exists
  *
- *  6. GLM TIMEOUT INCREASED:
- *     - 25s timeout instead of 15s
- *
- *  7. COMBAT: flee earlier (hp<12), fight smarter
+ *  6. SPAM KICK HANDLER:
+ *     - Detect "disconnect.spam" specifically
+ *     - 30s reconnect + clear shelter building state
+ *     - Set _skipShelterBuild flag for 60s after spam kick
  *
  *  ARCHITECTURE: PERCEIVE -> THINK -> EXECUTE
  *  AI: GLM-4-flash (free, unlimited, ultra-fast)
@@ -68,6 +70,7 @@ const CONFIG = {
 // ═══════════════════════════════════════════════════════════════════════════
 const memory = {
   home: null,
+  shelterPos: null, // v12: remember built shelter position
   deathPoints: [],
   resourceLocations: {},
   playerLocations: {},
@@ -80,6 +83,7 @@ const memory = {
     try {
       writeFileSync(CONFIG.memoryFile, JSON.stringify({
         home: this.home,
+        shelterPos: this.shelterPos,
         deathPoints: this.deathPoints.slice(-20),
         resourceLocations: this.resourceLocations,
         playerLocations: this.playerLocations,
@@ -123,6 +127,12 @@ const state = {
   _nanCount: 0,
   _lastNanLogTime: 0,
   chatLog: [],
+  // v12: spam kick protection
+  _skipShelterBuild: false,
+  _lastSpamKickTime: 0,
+  _lastStarterGiveTime: 0,
+  _isBuildingShelter: false,
+  _kickReconnectDelay: 10000,
 };
 
 let bot = null;
@@ -149,6 +159,42 @@ function hasValidPosition() {
   return isFinite(p.x) && isFinite(p.y) && isFinite(p.z) && p.y > -64 && p.y < 320;
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// v12: THROTTLED COMMAND QUEUE — prevents spam kicks
+// Paper's default spam threshold is ~2 commands/second for chat-based commands
+// We send /setblock as chat commands, so we MUST rate-limit them
+// ═══════════════════════════════════════════════════════════════════════════
+const _cmdQueue = [];
+let _cmdQueueActive = false;
+const CMD_INTERVAL = 600; // 600ms between commands = ~1.67 cmd/s (under Paper's 2/s limit)
+
+async function throttledChat(msg) {
+  return new Promise((resolve) => {
+    _cmdQueue.push({ msg, resolve });
+    if (!_cmdQueueActive) processCommandQueue();
+  });
+}
+
+async function processCommandQueue() {
+  if (_cmdQueueActive) return;
+  _cmdQueueActive = true;
+
+  while (_cmdQueue.length > 0) {
+    const { msg, resolve } = _cmdQueue.shift();
+    try {
+      if (bot?.entity) {
+        bot.chat(msg);
+      }
+    } catch {}
+    resolve();
+    if (_cmdQueue.length > 0) {
+      await sleep(CMD_INTERVAL);
+    }
+  }
+
+  _cmdQueueActive = false;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Vec3 NaN GUARD — reject NaN at the Vec3 prototype level
 // ═══════════════════════════════════════════════════════════════════════════
@@ -174,15 +220,10 @@ function patchVec3RejectNaN(vec3Instance) {
 
 // ═══════════════════════════════════════════════════════════════════════════
 // RAW PACKET NaN INTERCEPTION — v10.0: THE REAL FIX
-// Intercept position packets BEFORE mineflayer processes them.
-// ViaVersion sometimes sends NaN position values in the SynchronizePlayerPosition
-// packet after respawn — this catches them at the source.
 // ═══════════════════════════════════════════════════════════════════════════
 function interceptRawPackets() {
   if (!bot?._client) return;
 
-  // Intercept SynchronizePlayerPosition packet (0x38 in 1.20.1)
-  // This is the packet that sets the player's position after login/respawn
   bot._client.on('position', (packet) => {
     if (!packet) return;
     const hasNaN = !isFinite(packet.x) || !isFinite(packet.y) || !isFinite(packet.z);
@@ -192,7 +233,6 @@ function interceptRawPackets() {
         console.log(`[Packet NaN] Intercepted NaN position packet: (${packet.x}, ${packet.y}, ${packet.z})`);
         state._lastNanLogTime = now;
       }
-      // Replace NaN with last known good position
       if (state._lastGoodPos) {
         packet.x = state._lastGoodPos.x;
         packet.y = state._lastGoodPos.y;
@@ -205,11 +245,9 @@ function interceptRawPackets() {
     }
   });
 
-  // Also intercept the entity position set from the server
   bot._client.on('packet', (data, meta) => {
     if (!meta || meta.name !== 'entity_position' || !data) return;
     if (!isFinite(data.x) || !isFinite(data.y) || !isFinite(data.z)) {
-      // Silently replace with 0 delta — don't let NaN propagate
       data.x = 0;
       data.y = 0;
       data.z = 0;
@@ -221,8 +259,6 @@ function interceptRawPackets() {
 
 // ═══════════════════════════════════════════════════════════════════════════
 // NaN POSITION ENFORCER — physicsTick backup
-// On EVERY physicsTick, if position is NaN, FORCE-RESTORE from _lastGoodPos
-// This is the backup for any NaN that slips past the packet interceptor
 // ═══════════════════════════════════════════════════════════════════════════
 function enforceValidPosition() {
   if (!bot?.entity) return;
@@ -241,7 +277,6 @@ function enforceValidPosition() {
       pos.z = state._lastGoodPos.z;
       vel.set(0, 0, 0);
 
-      // Throttle logging — only log every 5 seconds max
       const now = Date.now();
       if (state._nanCount <= 3 || now - state._lastNanLogTime > 5000) {
         console.log(`[NaN Fix] Restored position to ${posKey(state._lastGoodPos)} (count: ${state._nanCount})`);
@@ -257,7 +292,6 @@ function enforceValidPosition() {
       state._positionReady = true;
     }
   } else if (pos.y > -64 && pos.y < 320) {
-    // Update last good pos every tick (but only when position is valid)
     state._lastGoodPos = { x: pos.x, y: pos.y, z: pos.z };
     state._positionReady = true;
     if (state._nanCount > 0) {
@@ -283,7 +317,7 @@ async function callGLM(messages, maxTokens = CONFIG.maxTokens) {
         'Authorization': `Bearer ${CONFIG.glm.apiKey}`,
       },
       body: JSON.stringify({ model: CONFIG.glm.model, messages, max_tokens: maxTokens, temperature: 0.9, stream: false }),
-      signal: AbortSignal.timeout(25000), // Increased from 15s to 25s
+      signal: AbortSignal.timeout(25000),
     });
     if (!res.ok) return null;
     const data = await res.json();
@@ -338,6 +372,7 @@ function buildPerception() {
   const timeOfDay = bot.time?.timeOfDay ?? 0;
   const isNight = timeOfDay >= 13000 && timeOfDay < 23000;
   const inWater = isBotInWater();
+  const hasShelter = !!memory.shelterPos;
 
   return {
     pos: { x: Math.round(pos.x), y: Math.round(pos.y), z: Math.round(pos.z) },
@@ -345,7 +380,7 @@ function buildPerception() {
     food: Math.round((bot.food ?? 20) * 10) / 10,
     inv,
     nearby,
-    env: { isNight, isRaining: bot.isRaining ?? false, dim: bot.game?.dimension?.replace('minecraft:', '') ?? 'overworld', inWater },
+    env: { isNight, isRaining: bot.isRaining ?? false, dim: bot.game?.dimension?.replace('minecraft:', '') ?? 'overworld', inWater, hasShelter },
     chat: state._recentChat.slice(-3),
     act: state.activity,
   };
@@ -392,23 +427,28 @@ async function escapeWater() {
   state.activity = 'escaping_water';
   console.log('[Water] Bot is in water! Trying to escape...');
 
+  // v12: Use /tp to safety if stuck in water for too long
+  // First try walking out
   let landDir = null;
   let bestLandDist = Infinity;
 
   try {
-    for (let dx = -3; dx <= 3; dx++) {
-      for (let dz = -3; dz <= 3; dz++) {
+    for (let dx = -5; dx <= 5; dx++) {
+      for (let dz = -5; dz <= 5; dz++) {
         if (dx === 0 && dz === 0) continue;
         const checkX = Math.floor(bot.entity.position.x) + dx;
         const checkZ = Math.floor(bot.entity.position.z) + dz;
-        for (let dy = -1; dy <= 2; dy++) {
+        for (let dy = -1; dy <= 3; dy++) {
           const checkY = Math.floor(bot.entity.position.y) + dy;
           const block = bot.blockAt(checkX, checkY, checkZ);
           if (block && block.name !== 'water' && block.name !== 'air' && block.name !== 'lava') {
-            const dist = Math.abs(dx) + Math.abs(dz);
-            if (dist < bestLandDist) {
-              bestLandDist = dist;
-              landDir = { dx, dz };
+            const blockAbove = bot.blockAt(checkX, checkY + 1, checkZ);
+            if (blockAbove && blockAbove.name === 'air') {
+              const dist = Math.abs(dx) + Math.abs(dz);
+              if (dist < bestLandDist) {
+                bestLandDist = dist;
+                landDir = { dx, dz, dy };
+              }
             }
           }
         }
@@ -416,23 +456,42 @@ async function escapeWater() {
     }
   } catch {}
 
-  const moveDx = landDir ? landDir.dx : (Math.random() > 0.5 ? 1 : -1);
-  const moveDz = landDir ? landDir.dz : (Math.random() > 0.5 ? 1 : -1);
-  const yaw = Math.atan2(-moveDx, moveDz);
+  // If found land, walk toward it
+  if (landDir) {
+    const moveDx = landDir.dx;
+    const moveDz = landDir.dz;
+    const yaw = Math.atan2(-moveDx, moveDz);
 
-  try { await bot.look(yaw, 0, true); } catch {}
-  bot.setControlState('forward', true);
-  bot.setControlState('jump', true);
+    try { await bot.look(yaw, 0, true); } catch {}
+    bot.setControlState('forward', true);
+    bot.setControlState('jump', true);
 
-  for (let i = 0; i < 40; i++) {
-    await sleep(300);
-    if (!isBotInWater()) {
-      console.log('[Water] Escaped water!');
-      break;
+    for (let i = 0; i < 30; i++) {
+      await sleep(300);
+      if (!isBotInWater()) {
+        console.log('[Water] Escaped water by walking!');
+        break;
+      }
     }
+
+    clearAllControls();
+  }
+
+  // v12: If still in water after walking, /tp to safety
+  if (isBotInWater()) {
+    console.log('[Water] Still in water, using /tp to escape');
+    try {
+      if (memory.shelterPos) {
+        bot.chat(`/tp ${memory.shelterPos.x} ${memory.shelterPos.y} ${memory.shelterPos.z}`);
+      } else if (state._lastGoodPos) {
+        bot.chat(`/tp ${Math.floor(state._lastGoodPos.x)} ${Math.floor(state._lastGoodPos.y)} ${Math.floor(state._lastGoodPos.z)}`);
+      } else {
+        bot.chat('/tp ~80 ~ ~');
+      }
+      await sleep(2000);
+    } catch {}
   }
 
-  clearAllControls();
   state._drowningEscape = false;
   state.activity = 'idle';
 }
@@ -481,7 +540,6 @@ function startCombat(target) {
 
       bot.setControlState('sprint', false);
 
-      // Flee earlier — HP < 12 instead of < 8
       if (bot.health < 12) { stopCombat(); fleeFrom(target.position); }
     } catch { stopCombat(); }
   }, 600);
@@ -554,8 +612,6 @@ async function safeMoveTo(targetPos, range = 2) {
     moves.allow1by1towers = true;
     moves.allowParkour = false;
     moves.maxDropDown = 4;
-    // Water avoidance
-    moves.allowSprinting = false;
     bot.pathfinder.setMovements(moves);
 
     const goal = new goals.GoalNear(targetPos.x, targetPos.y, targetPos.z, range);
@@ -601,12 +657,13 @@ ${JSON.stringify(snapshot, null, 2)}
 Reglas de prioridad:
 1. Si estas en agua: salir del agua ya.
 2. Si hay mobs hostiles cerca y hp<12: HUIR. Si hp>=12 y tienes arma: pelear.
-3. Si es de noche sin cama: construir refugio de tierra o esconderse.
+3. Si es de noche sin cama y SIN refugio: construir refugio de tierra. Si ya tienes refugio: quedarte ahi.
 4. Si comida<14: comer algo.
 5. Si no tienes arma: talar arboles y hacer espada ASAP.
 6. NO repetir la misma accion. Varia: explorar, minar, talar, construir, mirar.
 7. Chat: SOLO si tienes algo que decir. NO hables cada ronda.
 8. NUNCA uses parentesis, "quilombo" (argentino), !! ?? mayusculas.
+9. Si ya tienes refugio (hasShelter=true) NO construyas otro.
 
 Responde SOLO JSON:
 {"thought":"tu pensamiento","emotion":"excited|focused|bored|cautious|curious|scared|happy|chill","action":"explore|mine|chop|build|fight|flee|eat|sleep|craft|farm|fish|socialize|look_around|idle","chat":"mensaje minusculas sin !! o vacio"}`;
@@ -682,8 +739,7 @@ function sendChat(msg) {
 }
 
 // ════════════════════════════════���══════════════════════════════════════════
-// SHELTER BUILDING — v10.0: Use /setblock commands (bot has OP!)
-// This is reliable — no facing/positioning issues like placeBlock
+// SHELTER — v12: WITH DOOR + RATE-LIMITED /setblock
 // ═══════════════════════════════════════════════════════════════════════════
 async function collectDirt(count = 10) {
   if (!bot?.entity || !hasValidPosition()) return false;
@@ -695,74 +751,89 @@ async function collectDirt(count = 10) {
   }
   if (dirtCount >= count) return true;
 
-  // If bot has OP, just /give dirt instead of mining
-  // But mining is more realistic and less cheaty
-  // Let's do a mix: mine if nearby dirt, otherwise /give
   console.log(`[Collect] Need ${count - dirtCount} more dirt blocks`);
 
-  let dug = 0;
-  const maxDig = Math.min(count - dirtCount, 8);
-
-  for (let i = 0; i < maxDig; i++) {
-    try {
-      if (!hasValidPosition()) break;
-      const block = bot.findBlock({ matching: (b) => b.name === 'dirt' || b.name === 'grass_block', maxDistance: 8 });
-      if (!block) {
-        // No nearby dirt — use /give as fallback since bot has OP
-        console.log('[Collect] No dirt nearby, using /give');
-        try {
-          bot.chat(`/give ${CONFIG.username} dirt ${maxDig - dug}`);
-          await sleep(1000);
-          dug = maxDig;
-        } catch {}
-        break;
-      }
-
-      if (hasValidPosition() && bot.entity.position.distanceTo(block.position) > 4) {
-        await safeMoveTo(block.position, 2);
-      }
-
-      if (bot.canDigBlock(block)) {
-        await bot.lookAt(block.position.offset(0.5, 0.5, 0.5), true);
-        await bot.dig(block);
-        dug++;
-        console.log(`[Collect] Dug dirt (${dug}/${maxDig})`);
-        await sleep(200);
-      }
-    } catch (e) {
-      console.error(`[Collect] Error digging: ${e.message}`);
-    }
-  }
+  // Since bot has OP, just /give dirt — faster and no spam risk
+  try {
+    await throttledChat(`/give ${CONFIG.username} dirt ${count - dirtCount}`);
+    await sleep(1500);
+  } catch {}
 
   let newDirtCount = 0;
   for (const item of bot.inventory.items()) {
     if (item.name.includes('dirt')) newDirtCount += item.count;
   }
-  console.log(`[Collect] Collected ${dug} dirt, now have ${newDirtCount}`);
+  console.log(`[Collect] Now have ${newDirtCount} dirt`);
   return newDirtCount >= 3;
 }
 
+// v12: Check if a shelter already exists at the remembered position
+function shelterExists() {
+  if (!memory.shelterPos || !bot) return false;
+  try {
+    const { x, y, z } = memory.shelterPos;
+    // Check a few key blocks: roof center, wall blocks
+    const roofCenter = bot.blockAt(x, y + 3, z);
+    const wall1 = bot.blockAt(x - 1, y, z - 1);
+    const wall2 = bot.blockAt(x + 1, y + 1, z + 1);
+    if (roofCenter?.name === 'dirt' && wall1?.name === 'dirt' && wall2?.name === 'dirt') {
+      return true;
+    }
+    // Shelter blocks gone (destroyed?) — clear cache
+    console.log('[Shelter] Previous shelter blocks missing, clearing cache');
+    memory.shelterPos = null;
+    memory.save();
+    return false;
+  } catch {
+    return false;
+  }
+}
+
 async function buildDirtShelter() {
   if (!bot?.entity || !hasValidPosition()) return false;
+
+  // v12: Don't build if recently spam-kicked
+  if (state._skipShelterBuild) {
+    console.log('[Shelter] Skipping build (recently spam-kicked)');
+    return false;
+  }
+
+  // v12: Don't build if shelter already exists
+  if (shelterExists()) {
+    console.log('[Shelter] Shelter already exists, going to it');
+    const sp = memory.shelterPos;
+    if (sp) {
+      await safeMoveTo({ x: sp.x, y: sp.y, z: sp.z }, 2);
+    }
+    return true;
+  }
+
+  // v12: Prevent double-build
+  if (state._isBuildingShelter) {
+    console.log('[Shelter] Already building, skipping');
+    return false;
+  }
+
+  state._isBuildingShelter = true;
   state.activity = 'building';
 
-  // v10.0: Use /setblock commands — 100% reliable, no facing/positioning needed
   const pos = bot.entity.position;
   const bx = Math.floor(pos.x);
   const by = Math.floor(pos.y);
   const bz = Math.floor(pos.z);
 
-  console.log(`[Shelter] Building dirt shelter at ${bx},${by},${bz} using /setblock`);
+  console.log(`[Shelter] Building dirt shelter at ${bx},${by},${bz} using THROTTLED /setblock`);
 
-  let placed = 0;
   const commands = [];
 
-  // Floor (under the bot is already there)
   // Walls around bot (3x3 perimeter, 3 blocks high)
+  // v12: Leave a DOOR at (bx+1, by, bz-1) — one wall block open at feet level
   for (let dx = -1; dx <= 1; dx++) {
     for (let dz = -1; dz <= 1; dz++) {
       if (dx === 0 && dz === 0) continue; // Leave center open for bot
       for (let dy = 0; dy <= 2; dy++) {
+        // DOOR: skip the block at dx=1, dz=-1, dy=0 (entrance at feet level)
+        if (dx === 1 && dz === -1 && dy === 0) continue;
         commands.push(`/setblock ${bx + dx} ${by + dy} ${bz + dz} dirt`);
       }
     }
@@ -774,22 +845,28 @@ async function buildDirtShelter() {
     }
   }
 
-  // Execute all setblock commands with small delays
+  // v12: Execute with THROTTLED command queue — each command gets 600ms delay
+  let placed = 0;
   for (const cmd of commands) {
     try {
-      bot.chat(cmd);
+      await throttledChat(cmd);
       placed++;
-      // Small delay to avoid command spam
-      if (placed % 5 === 0) await sleep(300);
     } catch {}
   }
-  await sleep(500); // Wait for all blocks to be placed
 
-  console.log(`[Shelter] Placed ${placed} blocks via /setblock`);
-  if (!memory.home && hasValidPosition()) {
+  // Wait for all commands to be processed
+  await sleep(1000 + commands.length * 100);
+
+  console.log(`[Shelter] Placed ${placed} blocks via throttled /setblock`);
+
+  // v12: Remember shelter position
+  memory.shelterPos = { x: bx, y: by, z: bz };
+  if (!memory.home) {
     memory.home = { x: bx, y: by, z: bz };
-    memory.save();
   }
+  memory.save();
+
+  state._isBuildingShelter = false;
   return placed > 0;
 }
 
@@ -842,14 +919,28 @@ async function executeAction(decision) {
   const timeOfDay = bot.time?.timeOfDay ?? 0;
   const isNight = timeOfDay >= 13000 && timeOfDay < 23000;
   if (isNight && actionType === 'explore') {
-    actionType = 'build';
-    console.log('[Survival] Night override: building shelter instead of exploring');
+    // v12: If shelter exists, go to it instead of building new one
+    if (shelterExists()) {
+      actionType = 'idle';
+      console.log('[Survival] Night + shelter exists, staying inside');
+    } else {
+      actionType = 'build';
+      console.log('[Survival] Night override: building shelter instead of exploring');
+    }
   }
 
-  // Anti-repeat
+  // v12: Don't build if shelter already exists
+  if (actionType === 'build' && shelterExists()) {
+    actionType = 'idle';
+    console.log('[Survival] Shelter exists, skipping build');
+  }
+
+  // Anti-repeat — v12: lowered threshold to 3, include 'build' in alternatives for night
   trackAction(actionType);
-  if (getRepeatedCount(actionType) >= 4) {
-    const alternatives = ['explore', 'look_around', 'chop', 'mine', 'idle', 'craft'];
+  if (getRepeatedCount(actionType) >= 3) {
+    const alternatives = isNight
+      ? ['build', 'look_around', 'mine', 'idle', 'craft', 'eat']
+      : ['explore', 'look_around', 'chop', 'mine', 'idle', 'craft'];
     const filtered = alternatives.filter(a => a !== actionType);
     actionType = filtered[rand(0, filtered.length - 1)];
     console.log(`[Bot] Anti-repeat: forcing ${actionType}`);
@@ -984,9 +1075,11 @@ async function executeAction(decision) {
             if (recipes.length > 0) {
               const existing = bot.inventory.items().find(i => i.name === name);
               if (existing) continue;
-              await bot.craft(recipes[0], 1, null);
-              console.log(`[Action] Crafted ${name}`);
+              const recipe = recipes[0];
+              bot.craft(recipe, 1, null);
               crafted = true;
+              console.log(`[Action] Crafted ${name}`);
+              await sleep(1000);
               break;
             }
           } catch {}
@@ -996,84 +1089,24 @@ async function executeAction(decision) {
       }
 
       case 'build': {
-        state.activity = 'building';
-        const isNightNow = (bot.time?.timeOfDay ?? 0) >= 13000 && (bot.time?.timeOfDay ?? 0) < 23000;
-        if (isNightNow) {
-          const built = await buildDirtShelter();
-          if (built) sendChat('ya tengo mi refugio wey');
-        } else {
-          // During day, just build a small structure
-          const placeable = bot.inventory.items().find(i => i.name.includes('_planks') || i.name.includes('cobblestone') || i.name.includes('dirt'));
-          if (placeable && hasValidPosition()) {
-            // Use /setblock for reliable placement
-            const pos = bot.entity.position;
-            const fx = Math.floor(pos.x) + rand(-2, 2);
-            const fz = Math.floor(pos.z) + rand(-2, 2);
-            const fy = Math.floor(pos.y);
-            try {
-              bot.chat(`/setblock ${fx} ${fy} ${fz} dirt`);
-              console.log(`[Action] Placed dirt at ${fx},${fy},${fz}`);
-            } catch {}
-          }
-        }
-        if (!memory.home && hasValidPosition()) {
-          const pos = bot.entity.position;
-          memory.home = { x: Math.round(pos.x), y: Math.round(pos.y), z: Math.round(pos.z) };
-          memory.save();
+        const built = await buildDirtShelter();
+        if (built) {
+          sendChat('ya tengo mi refugio wey');
         }
         break;
       }
 
-      case 'farm': {
-        state.activity = 'farming';
-        const grass = bot.findBlock({ matching: (b) => b.name === 'grass_block' || b.name === 'dirt', maxDistance: 8 });
-        if (grass) {
-          const hoe = bot.inventory.items().find(i => i.name.includes('hoe'));
-          if (hoe) {
-            await bot.equip(hoe, 'hand');
-            await bot.activateBlock(grass);
-            const seeds = bot.inventory.items().find(i => i.name.includes('seeds'));
-            if (seeds) {
-              await bot.equip(seeds, 'hand');
-              await bot.activateBlock(grass);
-            }
-          }
-        }
-        break;
-      }
-
-      case 'fish': {
-        state.activity = 'fishing';
-        const rod = bot.inventory.items().find(i => i.name.includes('fishing_rod'));
-        if (rod) {
-          await bot.equip(rod, 'hand');
-          const water = bot.findBlock({ matching: (b) => b.name === 'water', maxDistance: 10 });
-          if (water) await bot.lookAt(water.position);
-          await bot.activateItem();
-          await sleep(5000 + Math.random() * 8000);
-          await bot.activateItem();
-        } else {
-          state.activity = 'idle';
-        }
-        break;
-      }
-
-      case 'socialize': {
-        state.activity = 'socializing';
-        const players = Object.keys(bot.players).filter(n => n !== CONFIG.username);
-        if (players.length > 0) {
-          const target = players[rand(0, players.length - 1)];
-          const msgs = ['hola wey', 'que onda', 'buenas', 'orale', 'holi'];
-          sendChat(`${msgs[rand(0, msgs.length - 1)]} ${target}`);
-        }
+      case 'farm': case 'fish': case 'socialize': {
+        state.activity = 'idle';
+        await simpleWalk(2000 + Math.random() * 3000);
         break;
       }
 
       case 'look_around': {
-        state.activity = 'looking_around';
+        state.activity = 'looking';
         for (let i = 0; i < 3; i++) {
-          await bot.look(bot.entity.yaw + (Math.random() - 0.5) * 1.5, bot.entity.pitch + (Math.random() - 0.5) * 0.4, true);
-          await sleep(800);
+          await bot.look(bot.entity.yaw + (Math.random() - 0.5) * Math.PI, bot.entity.pitch + (Math.random() - 0.5) * 0.5, true);
+          await sleep(1000 + Math.random() * 1000);
         }
         break;
       }
@@ -1081,12 +1114,10 @@ async function executeAction(decision) {
       case 'idle':
       default: {
         state.activity = 'idle';
-        await sleep(2000 + Math.random() * 3000);
+        await sleep(3000 + Math.random() * 3000);
         break;
       }
     }
-  } catch (e) {
-    console.error(`[Action] Error: ${e.message}`);
   } finally {
     clearAllControls();
     try { bot.pathfinder.setGoal(null); } catch {}
@@ -1195,12 +1226,18 @@ function addChatMessage(sender, text) {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// GIVE STARTER ITEMS — called on first spawn AND every respawn
+// GIVE STARTER ITEMS — v12: Smart debounce
 // ═══════════════════════════════════════════════════════════════════════════
 function giveStarterItems(force = false) {
   if (!bot?.entity) return;
   try {
-    // Check if bot already has essential items
+    // v12: Cooldown — don't re-give within 60 seconds (prevents spam on reconnect loop)
+    const now = Date.now();
+    if (!force && now - state._lastStarterGiveTime < 60000) {
+      console.log('[Starter] Skipping (60s cooldown)');
+      return;
+    }
+
     const hasSword = bot.inventory.items().some(i => i.name.includes('sword'));
     const hasPickaxe = bot.inventory.items().some(i => i.name.includes('pickaxe'));
     const hasFood = bot.inventory.items().some(i => isFoodItem(i.name) && i.count >= 5);
@@ -1210,11 +1247,13 @@ function giveStarterItems(force = false) {
     if (!needsItems) return;
 
     console.log('[Starter] Giving essential items...');
-    if (!hasSword) bot.chat(`/give ${CONFIG.username} wooden_sword 1`);
-    if (!hasPickaxe) bot.chat(`/give ${CONFIG.username} wooden_pickaxe 1`);
-    if (!hasFood) bot.chat(`/give ${CONFIG.username} cooked_beef 32`);
-    if (!hasDirt) bot.chat(`/give ${CONFIG.username} dirt 64`);
+    // v12: Use throttled queue for starter items too (4 commands = ~2.4s)
+    if (!hasSword) { bot.chat(`/give ${CONFIG.username} wooden_sword 1`); }
+    if (!hasPickaxe) { bot.chat(`/give ${CONFIG.username} wooden_pickaxe 1`); }
+    if (!hasFood) { bot.chat(`/give ${CONFIG.username} cooked_beef 32`); }
+    if (!hasDirt) { bot.chat(`/give ${CONFIG.username} dirt 64`); }
 
+    state._lastStarterGiveTime = now;
     memory.gotStarterItems = true;
     memory.save();
     console.log('[Starter] Items given!');
@@ -1232,6 +1271,7 @@ async function mainLoop() {
   while (true) {
     if (!bot?.entity) { await sleep(5000); continue; }
     if (state._isRespawning) { await sleep(2000); continue; }
+    if (state._isBuildingShelter) { await sleep(3000); continue; }
 
     try {
       const reflex = checkReflexes();
@@ -1274,6 +1314,7 @@ function createBot() {
   state._positionReady = false;
   state._actionInProgress = false;
   state._isRespawning = false;
+  state._isBuildingShelter = false;
   state._nanCount = 0;
   stopCombat();
   clearAllControls();
@@ -1287,13 +1328,11 @@ function createBot() {
 
   bot.setMaxListeners(30);
 
-  // Patch Vec3 to reject NaN values
   try {
     patchVec3RejectNaN(bot.entity.position);
     patchVec3RejectNaN(bot.entity.velocity);
   } catch {}
 
-  // v10.0: Intercept raw packets BEFORE mineflayer processes them
   interceptRawPackets();
 
   bot.loadPlugin(pathfinder);
@@ -1302,9 +1341,7 @@ function createBot() {
   try { bot.loadPlugin(armorManager); } catch {}
   try { bot.loadPlugin(collectBlock); } catch {}
 
-  // ══════════════════════════════════════════════════════════════════════════
-  // CRITICAL: physicsTick NaN Enforcer (backup for packet interceptor)
-  // ══════════════════════════════════════════════════════════════════════════
+  // v12: Use 'physicsTick' (not deprecated 'physicTick')
   bot.on('physicsTick', () => {
     enforceValidPosition();
   });
@@ -1315,7 +1352,6 @@ function createBot() {
     addChatMessage('System', `${CONFIG.username} connected`);
     saveStatus();
 
-    // Set keepInventory on first connection
     if (!memory.setKeepInventory) {
       setTimeout(() => {
         try {
@@ -1327,7 +1363,6 @@ function createBot() {
       }, 2000);
     }
 
-    // Give starter items on first spawn
     if (!memory.gotStarterItems) {
       setTimeout(() => giveStarterItems(true), 4000);
     }
@@ -1352,9 +1387,8 @@ function createBot() {
     }
 
     state._isRespawning = false;
+    state._isBuildingShelter = false;
 
-    // v10.0: Give starter items on every respawn (not just first)
-    // This ensures bot always has tools even if keepInventory somehow fails
     setTimeout(() => giveStarterItems(false), 3000);
 
     saveStatus();
@@ -1395,18 +1429,36 @@ function createBot() {
     console.warn(`[Bot] Kicked: ${reason}`);
     addChatMessage('System', `Kicked: ${reason}`);
     const reasonStr = typeof reason === 'string' ? reason : JSON.stringify(reason);
+
+    // v12: Detect SPAM kick specifically
+    const isSpamKick = reasonStr.includes('spam') || reasonStr.includes('Spam');
     const isInvalidMovement = reasonStr.includes('invalid_player_movement') || reasonStr.includes('Invalid move');
 
-    if (isInvalidMovement) {
+    if (isSpamKick) {
+      state._consecutiveKicks++;
+      // v12: Spam kick = long delay + skip shelter for 120s
+      const baseDelay = 30000; // 30s base for spam kicks
+      const backoffDelay = Math.min(baseDelay * Math.pow(1.5, state._consecutiveKicks - 1), 120000);
+      state._kickReconnectDelay = backoffDelay;
+      state._skipShelterBuild = true;
+      state._isBuildingShelter = false;
+      console.log(`[Bot] SPAM kick #${state._consecutiveKicks}, reconnect in ${Math.round(backoffDelay / 1000)}s, shelter skip for 120s`);
+
+      // Clear shelter skip after 120s
+      setTimeout(() => {
+        state._skipShelterBuild = false;
+        console.log('[Bot] Shelter build re-enabled');
+      }, 120000);
+    } else if (isInvalidMovement) {
       state._consecutiveKicks++;
       const baseDelay = 5000;
       const backoffDelay = Math.min(baseDelay * Math.pow(1.3, state._consecutiveKicks - 1), 60000);
-      console.log(`[Bot] Invalid movement kick #${state._consecutiveKicks}, reconnect in ${Math.round(backoffDelay / 1000)}s`);
       state._kickReconnectDelay = backoffDelay;
     } else {
       state._consecutiveKicks = 0;
       state._kickReconnectDelay = 10000;
     }
+
     state.activity = 'disconnected';
     stopCombat();
     clearAllControls();
@@ -1421,6 +1473,7 @@ function createBot() {
     state._actionInProgress = false;
     state._positionReady = false;
     state._isRespawning = false;
+    state._isBuildingShelter = false;
     stopCombat();
     clearAllControls();
     saveStatus();
@@ -1466,8 +1519,7 @@ function createBot() {
   });
 
   // ══════════════════════════════════════════════════════════════════════════
-  // SAFETY INTERVAL — v10.0: NO MORE /tp ~ ~ ~ SPAM
-  // Only resets stale control states and checks water
+  // SAFETY INTERVAL — v12: Minimal, no /tp spam
   // ══════════════════════════════════════════════════════════════════════════
   setInterval(() => {
     if (!bot?.entity) return;
@@ -1483,7 +1535,7 @@ function createBot() {
       escapeWater();
     }
 
-    // Only attempt single /tp if NaN has persisted for a VERY long time (1000+ ticks)
+    // Only /tp if NaN persists for EXTREMELY long
     if (!hasValidPosition() && state._nanCount > 1000) {
       console.error(`[Safety] NaN for ${state._nanCount} ticks. Single /tp attempt...`);
       try { bot.chat('/tp ~ ~ ~'); } catch {}
@@ -1507,12 +1559,13 @@ function createBot() {
 // START
 // ═══════════════════════════════════════════════════════════════════════════
 console.log('============================================');
-console.log('  Zelin MC Agent v10.0');
-console.log('  RAW PACKET NaN INTERCEPTION');
-console.log('  + /gamerule keepInventory true');
-console.log('  + /setblock shelter building');
-console.log('  + Starter items on every respawn');
-console.log('  + GLM 25s timeout');
+console.log('  Zelin MC Agent v12.0');
+console.log('  SPAM KICK FIX + RATE-LIMITED COMMANDS');
+console.log('  + Shelter with door');
+console.log('  + Shelter cache (no rebuild)');
+console.log('  + Smart starter item debounce');
+console.log('  + Anti-repeat threshold 3');
+console.log('  + Water /tp escape');
 console.log('  AI: GLM-4-flash (free, unlimited)');
 console.log('============================================');