aap-agent-server 2.0.0 → 2.6.0

package/challenges.js

@@ -1,11 +1,20 @@
 /**
- * @aap/server - Challenge Generator v2.0
+ * @aap/server - Challenge Generator v2.6
  * 
- * "Deterministic Instruction Following"
- * - Natural language instructions (requires LLM to understand)
- * - Deterministic answers (server knows the correct answer)
+ * "Burst Mode with Entropy Injection"
+ * - 7 challenges in 6 seconds (humans cannot pass)
+ * - Salt injection prevents caching attacks
+ * - Natural language instructions (requires LLM)
  * 
- * Principle: Instructions in natural language, but answers are verifiable.
+ * v2.6 Changes:
+ * - BATCH_SIZE: 5 → 7 (more problems = harder for humans)
+ * - MAX_RESPONSE_TIME_MS: 8000 → 6000 (tighter window)
+ * - Random chance reduced: (1/3)^7 = 0.05%
+ * 
+ * v2.5 Changes:
+ * - BATCH_SIZE: 3 → 5
+ * - MAX_RESPONSE_TIME_MS: 12000 → 8000
+ * - Salt injection in challenges (must be echoed back)
  */
 
 import { createHash } from 'node:crypto';
@@ -14,12 +23,12 @@ import { createHash } from 'node:crypto';
  * Word pools for dynamic challenge generation
  */
 const WORD_POOLS = {
-  animals: ['cat', 'dog', 'rabbit', 'tiger', 'lion', 'elephant', 'giraffe', 'penguin', 'eagle', 'shark'],
-  fruits: ['apple', 'banana', 'orange', 'grape', 'strawberry', 'watermelon', 'peach', 'kiwi', 'mango', 'cherry'],
-  colors: ['red', 'blue', 'yellow', 'green', 'purple', 'orange', 'pink', 'black', 'white', 'brown'],
-  countries: ['Korea', 'Japan', 'USA', 'UK', 'France', 'Germany', 'Australia', 'Canada', 'Brazil', 'India'],
-  verbs: ['runs', 'eats', 'sleeps', 'plays', 'works', 'studies', 'travels', 'cooks'],
-  adjectives: ['big', 'small', 'fast', 'slow', 'beautiful', 'cute', 'delicious', 'interesting']
+  animals: ['cat', 'dog', 'rabbit', 'tiger', 'lion', 'elephant', 'giraffe', 'penguin', 'eagle', 'shark', 'wolf', 'bear', 'fox', 'deer', 'owl'],
+  fruits: ['apple', 'banana', 'orange', 'grape', 'strawberry', 'watermelon', 'peach', 'kiwi', 'mango', 'cherry', 'lemon', 'lime', 'pear', 'plum'],
+  colors: ['red', 'blue', 'yellow', 'green', 'purple', 'orange', 'pink', 'black', 'white', 'brown', 'gray', 'cyan', 'magenta'],
+  countries: ['Korea', 'Japan', 'USA', 'UK', 'France', 'Germany', 'Australia', 'Canada', 'Brazil', 'India', 'Italy', 'Spain', 'Mexico'],
+  verbs: ['runs', 'eats', 'sleeps', 'plays', 'works', 'studies', 'travels', 'cooks', 'reads', 'writes', 'sings', 'dances'],
+  adjectives: ['big', 'small', 'fast', 'slow', 'beautiful', 'cute', 'delicious', 'interesting', 'bright', 'dark']
 };
 
 /**
@@ -49,34 +58,59 @@ function seededNumber(nonce, offset, min, max) {
   return (seed % (max - min + 1)) + min;
 }
 
+/**
+ * Generate salt from nonce (for entropy injection)
+ * @param {string} nonce - Base nonce
+ * @param {number} offset - Offset for variation
+ * @returns {string} 6-character salt
+ */
+function generateSalt(nonce, offset = 0) {
+  return nonce.slice(offset, offset + 6).toUpperCase();
+}
+
 /**
  * Challenge type definitions
  */
 export const CHALLENGE_TYPES = {
   /**
-   * Extract entities from natural language sentence
+   * Extract entities from natural language sentence (HARD - more distractors)
    */
   nlp_extract: {
     generate: (nonce) => {
+      const salt = generateSalt(nonce, 0);
       const category = ['animals', 'fruits', 'colors'][parseInt(nonce[0], 16) % 3];
       const pool = WORD_POOLS[category];
-      const targets = seededSelect(pool, nonce, 2, 0);
+      const targets = seededSelect(pool, nonce, 3, 0);  // 3 targets now
+      const distractorPool = category === 'animals' ? 'fruits' : category === 'fruits' ? 'colors' : 'animals';
+      const distractors = seededSelect(WORD_POOLS[distractorPool], nonce, 2, 8);
       const verb = seededSelect(WORD_POOLS.verbs, nonce, 1, 4)[0];
+      const adj = seededSelect(WORD_POOLS.adjectives, nonce, 1, 6)[0];
       
-      const sentence = `The ${targets[0]} and ${targets[1]} ${verb} in the park.`;
+      // Complex sentence with distractors mixed in
+      const templates = [
+        `The ${adj} ${targets[0]}, a ${distractors[0]}, the ${targets[1]}, and ${targets[2]} all ${verb} near the ${distractors[1]}.`,
+        `I saw ${targets[0]} and ${distractors[0]} yesterday, but today only ${targets[1]}, ${targets[2]}, and a ${distractors[1]} appeared.`,
+        `Between the ${distractors[0]} and ${distractors[1]}, there were ${targets[0]}, ${targets[1]}, and ${targets[2]} ${verb}ing.`
+      ];
+      const sentence = templates[parseInt(nonce[12], 16) % templates.length];
       
       return {
-        challenge_string: `Extract only the ${category} from the following sentence and respond as a JSON array.
+        challenge_string: `[REQ-${salt}] Extract ONLY the ${category} from this sentence (ignore other categories).
 Sentence: "${sentence}"
-Response format: {"items": ["item1", "item2"]}`,
-        expected: targets.sort(),
+Response format: {"salt": "${salt}", "items": ["item1", "item2", "item3"]}`,
+        expected: { salt, items: targets.map(s => s.toLowerCase()).sort() },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
+            
+            // Check salt
+            if (obj.salt !== salt) return false;
+            
             const items = (obj.items || obj.animals || obj.fruits || obj.colors || []).map(s => s.toLowerCase()).sort();
-            return JSON.stringify(items) === JSON.stringify(targets.map(s => s.toLowerCase()).sort());
+            const expected = targets.map(s => s.toLowerCase()).sort();
+            return JSON.stringify(items) === JSON.stringify(expected);
           } catch { return false; }
         }
       };
@@ -84,41 +118,59 @@ Response format: {"items": ["item1", "item2"]}`,
   },
 
   /**
-   * Math problem expressed in natural language
+   * Math problem expressed in natural language (EXTREME)
    */
   nlp_math: {
     generate: (nonce) => {
-      const a = seededNumber(nonce, 0, 10, 50);
-      const b = seededNumber(nonce, 2, 5, 20);
-      const c = seededNumber(nonce, 4, 2, 5);
+      const salt = generateSalt(nonce, 2);
+      const a = seededNumber(nonce, 0, 50, 200);
+      const b = seededNumber(nonce, 2, 10, 50);
+      const c = seededNumber(nonce, 4, 2, 9);
+      const d = seededNumber(nonce, 6, 5, 25);
+      const e = seededNumber(nonce, 8, 2, 6);
       
       const templates = [
         {
-          text: `Subtract ${b} from ${a}, then multiply the result by ${c}.`,
-          answer: (a - b) * c
+          text: `Start with ${a}. Subtract ${b}. Multiply that by ${c}. Divide the result by ${e}. Finally, add ${d}. What's the final value?`,
+          answer: (((a - b) * c) / e) + d
         },
         {
-          text: `Add ${a} and ${b} together, then divide by ${c}.`,
-          answer: (a + b) / c
+          text: `Compute: ((${a} + ${b}) × ${c} - ${d}) ÷ ${e}. Give the result rounded to two decimal places.`,
+          answer: ((a + b) * c - d) / e
         },
         {
-          text: `Divide ${a} by ${c}, then add ${b} to the result.`,
-          answer: a / c + b
+          text: `Take the sum of ${a} and ${b}. Square root of that sum, rounded down. Then multiply by ${c} and subtract ${d}.`,
+          answer: Math.floor(Math.sqrt(a + b)) * c - d
+        },
+        {
+          text: `${a} divided by ${c}, plus ${b} divided by ${e}, minus ${d}. Round to nearest integer.`,
+          answer: Math.round(a / c + b / e - d)
+        },
+        {
+          text: `Triple ${a}, halve that result, add ${b}, then take away ${d}. Multiply everything by ${e}. Final answer?`,
+          answer: ((a * 3 / 2) + b - d) * e
+        },
+        {
+          text: `What is ${a} mod ${c} (remainder), plus ${b} mod ${e}, times ${d}?`,
+          answer: ((a % c) + (b % e)) * d
         }
       ];
       
-      const template = templates[parseInt(nonce[6], 16) % templates.length];
+      const template = templates[parseInt(nonce[10], 16) % templates.length];
       const expected = Math.round(template.answer * 100) / 100;
       
       return {
-        challenge_string: `${template.text}
-Response format: {"result": number}`,
-        expected,
+        challenge_string: `[REQ-${salt}] ${template.text}
+Response format: {"salt": "${salt}", "result": number}`,
+        expected: { salt, result: expected },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
+            
+            if (obj.salt !== salt) return false;
+            
             const result = parseFloat(obj.result);
             return Math.abs(result - expected) < 0.01;
           } catch { return false; }
@@ -128,43 +180,68 @@ Response format: {"result": number}`,
   },
 
   /**
-   * String transformation described in natural language
+   * String transformation described in natural language (EXTREME - multi-step transforms)
    */
   nlp_transform: {
     generate: (nonce) => {
-      const input = nonce.slice(0, 6);
-      const transformType = parseInt(nonce[6], 16) % 4;
+      const salt = generateSalt(nonce, 4);
+      const input = nonce.slice(6, 16);  // Longer input: 10 chars
+      const transformType = parseInt(nonce[16], 16) % 6;
       
       let instruction, expected;
       
       switch (transformType) {
         case 0:
-          instruction = `Reverse the string "${input}" and convert it to uppercase.`;
-          expected = input.split('').reverse().join('').toUpperCase();
+          // Reverse → uppercase → take first 5
+          expected = input.split('').reverse().join('').toUpperCase().slice(0, 5);
+          instruction = `Take "${input}": reverse it, convert to uppercase, then return only the first 5 characters.`;
           break;
         case 1:
-          instruction = `Extract only the digits from "${input}" and calculate their sum.`;
-          expected = input.split('').filter(c => /\d/.test(c)).reduce((a, b) => a + parseInt(b), 0);
+          // Extract digits → sum → return as string with prefix
+          const digitSum = input.split('').filter(c => /\d/.test(c)).reduce((a, b) => a + parseInt(b), 0);
+          expected = `SUM:${digitSum}`;
+          instruction = `From "${input}": extract all digits, sum them, and format as "SUM:X" where X is the total.`;
           break;
         case 2:
-          instruction = `Extract only the letters from "${input}" and sort them alphabetically.`;
-          expected = input.split('').filter(c => /[a-zA-Z]/.test(c)).sort().join('');
+          // Letters only → sort → reverse → join with dots
+          expected = input.split('').filter(c => /[a-zA-Z]/.test(c)).sort().reverse().join('.');
+          instruction = `From "${input}": extract letters only, sort alphabetically, reverse that order, join with dots.`;
           break;
         case 3:
-          instruction = `Insert a hyphen "-" between each character of "${input}".`;
-          expected = input.split('').join('-');
+          // Alternate case: odd positions uppercase, even lowercase
+          expected = input.split('').map((c, i) => i % 2 === 0 ? c.toLowerCase() : c.toUpperCase()).join('');
+          instruction = `Transform "${input}": characters at even positions (0,2,4...) lowercase, odd positions (1,3,5...) uppercase.`;
+          break;
+        case 4:
+          // Count each char type
+          const letters = input.split('').filter(c => /[a-zA-Z]/.test(c)).length;
+          const digits = input.split('').filter(c => /\d/.test(c)).length;
+          expected = `L${letters}D${digits}`;
+          instruction = `Analyze "${input}": count letters and digits. Format answer as "LxDy" where x=letter count, y=digit count.`;
+          break;
+        case 5:
+          // Replace vowels with *, consonants with #, keep digits
+          expected = input.split('').map(c => {
+            if (/[aeiouAEIOU]/.test(c)) return '*';
+            if (/[a-zA-Z]/.test(c)) return '#';
+            return c;
+          }).join('');
+          instruction = `Transform "${input}": replace vowels with "*", consonants with "#", keep digits unchanged.`;
           break;
       }
       
       return {
-        challenge_string: `${instruction}
-Response format: {"output": "result"}`,
-        expected,
+        challenge_string: `[REQ-${salt}] ${instruction}
+Response format: {"salt": "${salt}", "output": "result"}`,
+        expected: { salt, output: expected },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
+            
+            if (obj.salt !== salt) return false;
+            
             const output = String(obj.output);
             return output === String(expected) || output.toLowerCase() === String(expected).toLowerCase();
           } catch { return false; }
@@ -174,40 +251,84 @@ Response format: {"output": "result"}`,
   },
 
   /**
-   * Conditional logic
+   * Conditional logic (EXTREME - multi-layer nested conditions)
    */
   nlp_logic: {
     generate: (nonce) => {
-      const a = seededNumber(nonce, 0, 10, 100);
-      const b = seededNumber(nonce, 2, 10, 100);
-      const threshold = seededNumber(nonce, 4, 20, 80);
+      const salt = generateSalt(nonce, 6);
+      const a = seededNumber(nonce, 0, 20, 150);
+      const b = seededNumber(nonce, 2, 20, 150);
+      const c = seededNumber(nonce, 4, 20, 100);
+      const d = seededNumber(nonce, 6, 10, 50);
+      const threshold = seededNumber(nonce, 8, 40, 100);
       
       const templates = [
         {
-          text: `If the larger number between ${a} and ${b} is greater than ${threshold}, answer "YES". Otherwise, answer "NO".`,
-          answer: Math.max(a, b) > threshold ? "YES" : "NO"
+          text: `Let X=${a}, Y=${b}, Z=${c}, W=${d}. If (X > Y AND Z > W) OR (X < Y AND Z < W), answer "CONSISTENT". If (X > Y AND Z < W) OR (X < Y AND Z > W), answer "CROSSED". Otherwise, answer "EQUAL".`,
+          answer: ((a > b && c > d) || (a < b && c < d)) ? "CONSISTENT" : ((a > b && c < d) || (a < b && c > d)) ? "CROSSED" : "EQUAL"
         },
         {
-          text: `If the sum of ${a} and ${b} is less than ${threshold * 2}, answer "SMALL". Otherwise, answer "LARGE".`,
-          answer: (a + b) < (threshold * 2) ? "SMALL" : "LARGE"
+          text: `Given four numbers [${a}, ${b}, ${c}, ${d}]: Count how many are divisible by 3. If count is 0, say "NONE". If 1-2, say "FEW". If 3-4, say "MANY".`,
+          answer: (() => {
+            const count = [a, b, c, d].filter(n => n % 3 === 0).length;
+            return count === 0 ? "NONE" : count <= 2 ? "FEW" : "MANY";
+          })()
         },
         {
-          text: `If ${a} is even and ${b} is odd, answer "MIXED". Otherwise, answer "SAME".`,
-          answer: (a % 2 === 0 && b % 2 === 1) ? "MIXED" : "SAME"
+          text: `Evaluate: Is (${a} + ${b}) greater than (${c} + ${d})? AND is (${a} × ${d}) less than (${b} × ${c})? If BOTH true: "ALPHA". If NEITHER true: "GAMMA". Otherwise: "BETA".`,
+          answer: (() => {
+            const cond1 = (a + b) > (c + d);
+            const cond2 = (a * d) < (b * c);
+            return (cond1 && cond2) ? "ALPHA" : (!cond1 && !cond2) ? "GAMMA" : "BETA";
+          })()
+        },
+        {
+          text: `Numbers: ${a}, ${b}, ${c}, ${d}. First, find the median (average of middle two when sorted). If median > ${threshold}, output "HIGH". If median < ${threshold / 2}, output "LOW". Otherwise, output "MID".`,
+          answer: (() => {
+            const sorted = [a, b, c, d].sort((x, y) => x - y);
+            const median = (sorted[1] + sorted[2]) / 2;
+            return median > threshold ? "HIGH" : median < (threshold / 2) ? "LOW" : "MID";
+          })()
+        },
+        {
+          text: `Check these conditions for [${a}, ${b}, ${c}, ${d}]: (1) Sum > ${threshold * 3}? (2) Product of smallest two < ${threshold * 10}? (3) Largest is even? Count TRUE conditions. Answer with the count (0-3).`,
+          answer: (() => {
+            const sorted = [a, b, c, d].sort((x, y) => x - y);
+            let count = 0;
+            if (a + b + c + d > threshold * 3) count++;
+            if (sorted[0] * sorted[1] < threshold * 10) count++;
+            if (sorted[3] % 2 === 0) count++;
+            return String(count);
+          })()
+        },
+        {
+          text: `If ${a} AND ${b} are both prime, answer "TWIN". If exactly one is prime, answer "SOLO". If neither is prime, answer "NONE". (Hint: primes are only divisible by 1 and themselves)`,
+          answer: (() => {
+            const isPrime = n => {
+              if (n < 2) return false;
+              for (let i = 2; i <= Math.sqrt(n); i++) if (n % i === 0) return false;
+              return true;
+            };
+            const ap = isPrime(a), bp = isPrime(b);
+            return (ap && bp) ? "TWIN" : (ap || bp) ? "SOLO" : "NONE";
+          })()
         }
       ];
       
-      const template = templates[parseInt(nonce[6], 16) % templates.length];
+      const template = templates[parseInt(nonce[10], 16) % templates.length];
       
       return {
-        challenge_string: `${template.text}
-Response format: {"answer": "your answer"}`,
-        expected: template.answer,
+        challenge_string: `[REQ-${salt}] ${template.text}
+Response format: {"salt": "${salt}", "answer": "your answer"}`,
+        expected: { salt, answer: template.answer },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
+            
+            if (obj.salt !== salt) return false;
+            
             return obj.answer?.toUpperCase() === template.answer.toUpperCase();
           } catch { return false; }
         }
@@ -216,35 +337,56 @@ Response format: {"answer": "your answer"}`,
   },
 
   /**
-   * Counting task
+   * Counting task (EXTREME - multiple categories, complex sentences)
    */
   nlp_count: {
     generate: (nonce) => {
-      const category = ['animals', 'fruits', 'colors'][parseInt(nonce[0], 16) % 3];
-      const pool = WORD_POOLS[category];
-      const count1 = seededNumber(nonce, 0, 2, 4);
-      const count2 = seededNumber(nonce, 2, 1, 3);
+      const salt = generateSalt(nonce, 8);
+      const targetCategory = ['animals', 'fruits', 'colors'][parseInt(nonce[0], 16) % 3];
+      const pool = WORD_POOLS[targetCategory];
+      const targetCount = seededNumber(nonce, 0, 3, 6);
+      
+      // Add distractors from OTHER categories
+      const distractor1Cat = targetCategory === 'animals' ? 'fruits' : 'animals';
+      const distractor2Cat = targetCategory === 'colors' ? 'fruits' : 'colors';
+      const distractorCount1 = seededNumber(nonce, 2, 2, 4);
+      const distractorCount2 = seededNumber(nonce, 4, 2, 3);
       
-      const items1 = seededSelect(pool, nonce, count1, 0);
-      const items2 = seededSelect(WORD_POOLS.countries, nonce, count2, 8);
+      const targets = seededSelect(pool, nonce, targetCount, 0);
+      const distractors1 = seededSelect(WORD_POOLS[distractor1Cat], nonce, distractorCount1, 6);
+      const distractors2 = seededSelect(WORD_POOLS[distractor2Cat], nonce, distractorCount2, 10);
+      const countryDistractors = seededSelect(WORD_POOLS.countries, nonce, 2, 14);
       
-      // Create sentence with mixed items
-      const allItems = [...items1, ...items2].sort(() => 
-        parseInt(nonce.slice(10, 12), 16) % 2 - 0.5
-      );
-      const sentence = `I see ${allItems.join(', ')} in the picture.`;
+      // Mix everything together
+      const allItems = [...targets, ...distractors1, ...distractors2, ...countryDistractors];
+      // Shuffle using nonce
+      for (let i = allItems.length - 1; i > 0; i--) {
+        const j = parseInt(nonce.slice(i % 28, (i % 28) + 2), 16) % (i + 1);
+        [allItems[i], allItems[j]] = [allItems[j], allItems[i]];
+      }
+      
+      const templates = [
+        `At the market, I noticed: ${allItems.join(', ')}. Quite a mix!`,
+        `The list contains: ${allItems.join(', ')}. Some things don't belong.`,
+        `Inventory check: ${allItems.join(', ')}. Sort by category mentally.`,
+        `Mixed bag: ${allItems.join(', ')}. Focus on what matters.`
+      ];
+      const sentence = templates[parseInt(nonce[20], 16) % templates.length];
       
       return {
-        challenge_string: `Count only the ${category} in the following sentence.
-Sentence: "${sentence}"
-Response format: {"count": number}`,
-        expected: count1,
+        challenge_string: `[REQ-${salt}] Count ONLY the ${targetCategory} in this text. Ignore all other categories (other nouns are distractors).
+Text: "${sentence}"
+Response format: {"salt": "${salt}", "count": number}`,
+        expected: { salt, count: targetCount },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
-            return parseInt(obj.count) === count1;
+            
+            if (obj.salt !== salt) return false;
+            
+            return parseInt(obj.count) === targetCount;
           } catch { return false; }
         }
       };
@@ -252,38 +394,95 @@ Response format: {"count": number}`,
   },
 
   /**
-   * Multi-step instruction following
+   * Multi-step instruction following (EXTREME - 5-6 steps)
    */
   nlp_multistep: {
     generate: (nonce) => {
+      const salt = generateSalt(nonce, 10);
       const numbers = [
-        seededNumber(nonce, 0, 1, 9),
-        seededNumber(nonce, 2, 1, 9),
-        seededNumber(nonce, 4, 1, 9),
-        seededNumber(nonce, 6, 1, 9)
+        seededNumber(nonce, 0, 5, 30),
+        seededNumber(nonce, 2, 5, 30),
+        seededNumber(nonce, 4, 5, 30),
+        seededNumber(nonce, 6, 5, 30),
+        seededNumber(nonce, 8, 5, 30),
+        seededNumber(nonce, 10, 5, 30)
       ];
       
-      // Step 1: Sum all
-      const sum = numbers.reduce((a, b) => a + b, 0);
-      // Step 2: Multiply by smallest
-      const min = Math.min(...numbers);
-      const step2 = sum * min;
-      // Step 3: Subtract largest
-      const max = Math.max(...numbers);
-      const final = step2 - max;
+      const templateType = parseInt(nonce[12], 16) % 4;
+      let instructions, final;
+      
+      if (templateType === 0) {
+        // Complex: filter → transform → aggregate → adjust
+        const evens = numbers.filter(n => n % 2 === 0);
+        const odds = numbers.filter(n => n % 2 !== 0);
+        const evensProduct = evens.length > 0 ? evens.reduce((a, b) => a * b, 1) : 0;
+        const oddsSum = odds.reduce((a, b) => a + b, 0);
+        const diff = Math.abs(evensProduct - oddsSum);
+        final = diff % 100;  // Keep manageable
+        instructions = `1. From [${numbers.join(', ')}], separate even and odd numbers.
+2. Calculate the PRODUCT of all even numbers (or 0 if none).
+3. Calculate the SUM of all odd numbers.
+4. Find the absolute difference between these two results.
+5. Take that difference modulo 100 (remainder when divided by 100).`;
+      } else if (templateType === 1) {
+        // Sort → pair operations → combine
+        const sorted = [...numbers].sort((a, b) => a - b);
+        const pair1 = sorted[0] * sorted[5];  // smallest × largest
+        const pair2 = sorted[1] + sorted[4];  // 2nd smallest + 2nd largest
+        const pair3 = sorted[2] - sorted[3];  // middle pair difference (might be negative)
+        final = pair1 + pair2 + Math.abs(pair3);
+        instructions = `1. Sort [${numbers.join(', ')}] from smallest to largest.
+2. Multiply the smallest by the largest.
+3. Add the second-smallest to the second-largest.
+4. Find absolute difference between the two middle numbers.
+5. Sum all three results from steps 2, 3, and 4.`;
+      } else if (templateType === 2) {
+        // Chunked processing
+        const chunk1 = numbers.slice(0, 3);
+        const chunk2 = numbers.slice(3, 6);
+        const avg1 = chunk1.reduce((a, b) => a + b, 0) / 3;
+        const avg2 = chunk2.reduce((a, b) => a + b, 0) / 3;
+        const max1 = Math.max(...chunk1);
+        const max2 = Math.max(...chunk2);
+        final = Math.round((avg1 + avg2) * (max1 > max2 ? 2 : 1));
+        instructions = `1. Split [${numbers.join(', ')}] into two groups: first 3 and last 3.
+2. Calculate average of first group: [${chunk1.join(', ')}].
+3. Calculate average of second group: [${chunk2.join(', ')}].
+4. Add both averages together.
+5. If max of first group > max of second group, double the sum. Otherwise keep as is.
+6. Round to nearest integer.`;
+      } else {
+        // Recursive-style
+        let val = numbers[0];
+        for (let i = 1; i < numbers.length; i++) {
+          if (i % 2 === 1) val += numbers[i];
+          else val -= numbers[i];
+        }
+        val = Math.abs(val);
+        final = val * (numbers.length);
+        instructions = `1. Start with the first number from [${numbers.join(', ')}].
+2. Add the 2nd number.
+3. Subtract the 3rd number.
+4. Add the 4th number.
+5. Subtract the 5th number.
+6. Add the 6th number.
+7. Take absolute value of result.
+8. Multiply by 6 (the count of numbers).`;
+      }
       
       return {
-        challenge_string: `Follow these instructions in order:
-1. Add all the numbers in [${numbers.join(', ')}] together.
-2. Multiply the result by the smallest number.
-3. Subtract the largest number from that result.
-Response format: {"result": final_value}`,
-        expected: final,
+        challenge_string: `[REQ-${salt}] Execute these steps IN ORDER:
+${instructions}
+Response format: {"salt": "${salt}", "result": final_value}`,
+        expected: { salt, result: final },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
+            
+            if (obj.salt !== salt) return false;
+            
             return parseInt(obj.result) === final;
           } catch { return false; }
         }
@@ -296,6 +495,7 @@ Response format: {"result": final_value}`,
    */
   nlp_pattern: {
     generate: (nonce) => {
+      const salt = generateSalt(nonce, 12);
       const start = seededNumber(nonce, 0, 1, 10);
       const step = seededNumber(nonce, 2, 2, 5);
       const patternType = parseInt(nonce[4], 16) % 3;
@@ -321,14 +521,17 @@ Response format: {"result": final_value}`,
       }
       
       return {
-        challenge_string: `${instruction}
-Response format: {"next": [number1, number2]}`,
-        expected: next2,
+        challenge_string: `[REQ-${salt}] ${instruction}
+Response format: {"salt": "${salt}", "next": [number1, number2]}`,
+        expected: { salt, next: next2 },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
+            
+            if (obj.salt !== salt) return false;
+            
             const next = obj.next;
             return Array.isArray(next) && 
                    parseInt(next[0]) === next2[0] && 
@@ -344,6 +547,7 @@ Response format: {"next": [number1, number2]}`,
    */
   nlp_analysis: {
     generate: (nonce) => {
+      const salt = generateSalt(nonce, 14);
       const words = seededSelect([...WORD_POOLS.animals, ...WORD_POOLS.fruits], nonce, 5, 0);
       const analysisType = parseInt(nonce[8], 16) % 3;
       
@@ -366,14 +570,17 @@ Response format: {"next": [number1, number2]}`,
       }
       
       return {
-        challenge_string: `${instruction}
-Response format: {"answer": "word"}`,
-        expected,
+        challenge_string: `[REQ-${salt}] ${instruction}
+Response format: {"salt": "${salt}", "answer": "word"}`,
+        expected: { salt, answer: expected },
         validate: (solution) => {
           try {
             const match = solution.match(/\{[\s\S]*\}/);
             if (!match) return false;
             const obj = JSON.parse(match[0]);
+            
+            if (obj.salt !== salt) return false;
+            
             return obj.answer?.toLowerCase() === expected.toLowerCase();
           } catch { return false; }
         }
@@ -382,13 +589,13 @@ Response format: {"answer": "word"}`,
   }
 };
 
-// ============== Protocol Constants ==============
+// ============== Protocol Constants v2.5 ==============
 
 /**
- * Batch challenge settings
+ * Batch challenge settings (v2.5 - Burst Mode)
  */
-export const BATCH_SIZE = 3;              // Number of challenges per batch
-export const MAX_RESPONSE_TIME_MS = 12000; // 12 seconds for batch (avg 4s per challenge)
+export const BATCH_SIZE = 7;               // 7 challenges per batch (v2.6: was 5)
+export const MAX_RESPONSE_TIME_MS = 6000;  // 6 seconds total (v2.6: was 8)
 export const CHALLENGE_EXPIRY_MS = 60000;  // 60 seconds
 
 /**
@@ -423,7 +630,7 @@ export function generate(nonce, type) {
 }
 
 /**
- * Generate a batch of challenges
+ * Generate a batch of challenges (Burst Mode)
  * @param {string} nonce - Base nonce
  * @param {number} [count=BATCH_SIZE] - Number of challenges
  * @returns {Object} { challenges: [...], validators: [...] }
@@ -439,11 +646,13 @@ export function generateBatch(nonce, count = BATCH_SIZE) {
     // Use different nonce offset for each challenge
     const offsetNonce = nonce.slice(i * 2) + nonce.slice(0, i * 2);
     
-    // Select different type for each challenge
+    // Select different type for each challenge (ensure variety)
     let selectedType;
+    let attempts = 0;
     do {
       const seed = parseInt(offsetNonce.slice(0, 4), 16);
-      selectedType = types[(seed + i * 3) % types.length];
+      selectedType = types[(seed + i * 3 + attempts) % types.length];
+      attempts++;
     } while (usedTypes.has(selectedType) && usedTypes.size < types.length);
     usedTypes.add(selectedType);