testronaut 1.2.5 → 1.3.1

package/bin/cli.js

@@ -29,7 +29,7 @@
  * Test strategy:
  *   To test pure helpers without running the whole CLI, we export a tiny test bundle:
  *     export const __test__ = { guessMimeType, safeJoin, findLatestReportPair, pkgManagerForCwd }
- *   See tests in tests/cliTests/cli.helpers.test.js
+ *   See tests in tests/toolsTests/cli.helpers.test.js
  */
 
 import fs from 'fs';
@@ -60,6 +60,11 @@ const apiBase = 'http://api.testronaut.app'; // Replace with your actual API bas
 
 const args = process.argv.slice(2);
 
+/**
+ * Read a JSONL steps file into an array of objects.
+ * @param {string} p
+ * @returns {object[]|null}
+ */
 function readJsonlSteps(p) {
   if (!p || !fs.existsSync(p)) return null;
   const lines = fs.readFileSync(p, 'utf8').split(/\r?\n/).filter(Boolean);
@@ -73,21 +78,27 @@ function readJsonlSteps(p) {
 /**
  * Merge duplicate turns without losing information.
  * Strategy:
- *  - Keep the latest **non-empty** version for a given turn if both exist
+ *  - Keep the latest **non-empty** version for a given (turn,retry) pair
  *  - If both are non-empty, keep the later one (last write wins)
  *  - Preserve original order by line index as a tiebreaker
+ *
+ * @param {Array} steps
+ * @returns {Array}
  */
 function mergeDuplicateTurns(steps) {
   const out = [];
-  const byTurn = new Map(); // turn -> index in out
+  const byKey = new Map(); // composite key -> index in out
   for (const s of steps) {
     const turn = Number.isFinite(s.turn) ? s.turn : out.length;
+    const attempt = Number.isFinite(s.retryAttempt) ? s.retryAttempt : 1;
     const hasEvents = Array.isArray(s.events) && s.events.length > 0;
-    if (!byTurn.has(turn)) {
+    const key = `${turn}::${attempt}`;
+
+    if (!byKey.has(key)) {
       out.push(s);
-      byTurn.set(turn, out.length - 1);
+      byKey.set(key, out.length - 1);
     } else {
-      const idx = byTurn.get(turn);
+      const idx = byKey.get(key);
       const existing = out[idx];
       const existingHasEvents = Array.isArray(existing.events) && existing.events.length > 0;
       // Prefer the one with events; if both have events, prefer the newer (s)
@@ -101,11 +112,28 @@ function mergeDuplicateTurns(steps) {
       }
     }
   }
-  // stable sort by `turn` ascending, then by original order via array index already preserved
-  out.sort((a, b) => (a.turn ?? 0) - (b.turn ?? 0));
+  // stable sort by `turn` then `retryAttempt`, then by original order
+  out.sort((a, b) => {
+    const ta = a.turn ?? 0;
+    const tb = b.turn ?? 0;
+    if (ta !== tb) return ta - tb;
+    const ra = Number.isFinite(a.retryAttempt) ? a.retryAttempt : 1;
+    const rb = Number.isFinite(b.retryAttempt) ? b.retryAttempt : 1;
+    if (ra !== rb) return ra - rb;
+    return 0;
+  });
   return out;
 }
 
+// Expose a small bundle for unit tests (helper-only; not the CLI flow)
+export const __test__ = {
+  guessMimeType,
+  safeJoin,
+  findLatestReportPair,
+  mergeDuplicateTurns,
+  readJsonlSteps,
+};
+
 // Look for --model=<id> or --model <id>
 let modelOverride;
 const modelFlagIndex = args.findIndex(a => a === '--model' || a.startsWith('--model='));
@@ -149,6 +177,37 @@ if (turnsFlagIndex >= 0) {
   args.splice(turnsFlagIndex, turnsOverride ? 2 : 1);
 }
 
+// Look for --retry_limit / --retry-limit
+let retryOverride;
+const retryFlagIndex = args.findIndex(a =>
+  a === '--retry_limit' ||
+  a.startsWith('--retry_limit=') ||
+  a === '--retry-limit' ||
+  a.startsWith('--retry-limit=')
+);
+if (retryFlagIndex >= 0) {
+  const rawArg = args[retryFlagIndex];
+  if (rawArg.includes('=')) {
+    retryOverride = rawArg.split('=')[1];
+  } else if (args[retryFlagIndex + 1]) {
+    retryOverride = args[retryFlagIndex + 1];
+  }
+
+  if (retryOverride) {
+    const n = Number(retryOverride.trim());
+    if (Number.isFinite(n)) {
+      const clamped = Math.min(10, Math.max(1, n));
+      process.env.TESTRONAUT_RETRY_LIMIT = String(clamped);
+      console.log(`🔁 Retry limit override: ${process.env.TESTRONAUT_RETRY_LIMIT} (allowed 1-10)`);
+    } else {
+      console.warn(`⚠️ Invalid --retry_limit value "${retryOverride}". Ignoring.`);
+    }
+  }
+
+  // Remove flag & value so they aren’t treated as filenames
+  args.splice(retryFlagIndex, retryOverride ? 2 : 1);
+}
+
 const missionsDir = path.resolve(process.cwd(), 'missions');
 
 const allResults = [];
@@ -170,6 +229,7 @@ Options:
   --init                    Scaffold project folders and a welcome mission
   --turns=<n>               Override max turns for this run (e.g., --turns=30)
   --help                    Show this help message
+  --retry_limit=<n>         Override agent turn retry limits (minimum 1, maximum 10)
 
 Examples:
   npx testronaut
@@ -720,6 +780,11 @@ function safeJoin(root, relUrlPath) {
   return resolved;
 }
 
+/**
+ * Best-effort cross-platform URL opener.
+ * @param {string} targetUrl
+ * @returns {Promise<void>}
+ */
 async function openInBrowser(targetUrl) {
   const platform = process.platform;
   const quoted = `"${targetUrl}"`;
@@ -848,4 +913,4 @@ try {
   }
 } catch (err) {
   console.warn(`⚠️ Could not remove tmp folder: ${err.message}`);
-}
+}

package/core/agent.js

@@ -25,6 +25,7 @@
 import 'dotenv/config';
 import { ChromeBrowser } from '../tools/chromeBrowser.js';
 import { turnLoop } from './turnLoop.js';
+import { createEmptyGroundControl, summarizeGroundControlForPrompt } from '../tools/contextControl.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -36,7 +37,7 @@ import path from 'path';
  * @param {number} [maxTurns=20] - upper bound for turnLoop per goal
  * @returns {Promise<Array<{missionName:string, submissionType:string, submissionName:string|null, status:'passed'|'failed', steps:any[], startTime:number, endTime:number}>>}
  */
-export async function runAgent(goals, missionName, maxTurns = 20) {
+export async function runAgent(goals, missionName, maxTurns = 20, retryLimit) {
   const browser = new ChromeBrowser();
   await browser.start();
   let result;
@@ -46,8 +47,12 @@ export async function runAgent(goals, missionName, maxTurns = 20) {
     const tmpDir = path.resolve(process.cwd(), 'missions/tmp');
     fs.mkdirSync(tmpDir, { recursive: true });
 
+    // 🔭 Shared Ground Control state across all goals/missions
+    const groundControl = createEmptyGroundControl();
+
     for (const goal of goals) {
       const steps = [];
+      const stepsArchive = [];
       // Unique-ish JSONL file for this mission’s steps
       const stepFile = path.join(
         tmpDir,
@@ -62,22 +67,79 @@ export async function runAgent(goals, missionName, maxTurns = 20) {
           ? goal.goal
           : goal?.goal?.toString?.() ?? String(goal.goal);
 
-      const messages = [
-        {
-          role: 'system',
-          content: `
-            You are an autonomous web agent. Use function calls to complete the user's goal.
-            If you are unsure of the selectors for inputs or buttons, call 'get_dom' to retrieve page HTML,
-            analyze it, then make your best guess based on labels, names, types, and placeholder values.
-            If you want to click a button labeled "Sign out", prefer:
+      // 🔭 Build a compact Ground Control snapshot for the prompt
+      const groundSummary = summarizeGroundControlForPrompt(groundControl);
+      let systemContent = `
+You are an autonomous web agent piloting a browser for end-to-end testing.
+
+Core behavior:
+- Use function calls to complete the user's goal.
+- If you are unsure of selectors for inputs or buttons, call 'get_dom' to retrieve page HTML,
+  analyze it, then choose selectors based on labels, names, types, and placeholder values.
+- If you want to click a button labeled "Sign out", prefer:
+
+  click_text({ text: "Sign out" })
+
+  Do NOT use CSS selectors like 'button:contains("Sign out")' — they are invalid.
+
+After completing the goal, respond with a final plain-text message starting with
+either "SUCCESS:" or "FAILURE:" followed by a short explanation.
+
+──── Ground Control (persistent mission state) ────
+You also have special tools to manage a compact, non-pruned state called "Ground Control".
+Ground Control tracks high-level truths about the app and session, such as:
 
-            click_text({ text: "Sign out" })
+- app:       { baseUrl, currentUrl, routeRole }          // where the app lives and where you are now
+- session:   { loggedIn, userLabel, tenant }             // login state and identity
+- navigation:{ currentLabel }                            // human label for the current view
+- constraints:{ stayWithinBaseUrl }                      // domain / navigation constraints
+- telemetry: [{ ts, kind, text, status, turn, extra }]   // optional breadcrumbs
 
-            Do NOT use CSS selectors like 'button:contains("Sign out")' — they are invalid.
+You have two Ground Control tools:
 
-            After completing the goal, respond with a final plain-text message starting with SUCCESS or FAILURE.
-          `.trim(),
-        },
+1) establish_ground_control
+   - Use this EARLY in a mission/phase once you understand key facts, e.g.:
+     - The base URL (e.g. "https://ult.ultimarii.app")
+     - The current URL and what the page represents (routeRole: "login", "chat", "dashboard", etc.)
+     - Whether you are logged in or not.
+   - Call it once per mission phase (premission / mission / postmission) when you first
+     have a clear picture of where you are and what the app state is.
+   - Provide as many known fields as you can, but do not guess wildly. Unknown fields can be omitted.
+
+2) update_ground_control
+   - Use this when important truths change or become clearer, for example:
+     - URL or routeRole changes after navigation or login.
+     - Login state changes (loggedIn false → true or vice versa).
+     - You discover the displayed user name or tenant.
+     - You identify a new page role (e.g. "chat", "settings", "feedback-form").
+   - Only update fields that changed or that you now know with more confidence.
+   - Optionally add short telemetry breadcrumbs about major milestones,
+     e.g. "Logged in and reached chat workspace".
+
+General rules:
+- Keep Ground Control high-level and stable; do NOT spam small, noisy updates.
+- Before leaving a page for a new flow, make sure Ground Control reflects the currentUrl
+  and routeRole so you can reason about where you are and where you’ve been.
+- Respect constraints (e.g. stayWithinBaseUrl = true) when deciding whether it is safe to navigate.
+
+Use Ground Control as your persistent mission memory about:
+- Where the app lives (baseUrl),
+- Where you are (currentUrl, routeRole),
+- Who you are logged in as (session),
+- Any constraints about staying on the correct site.
+      `.trim();
+
+      if (groundSummary) {
+        systemContent +=
+          '\n\n' +
+          `
+──── Ground Control Snapshot ────
+🛰️ ${JSON.stringify(groundSummary, null, 2)}
+          `.trim();
+      }
+
+      const messages = [
+        { role: 'system', content: systemContent },
         { role: 'user', content: userContent },
       ];
 
@@ -91,33 +153,34 @@ export async function runAgent(goals, missionName, maxTurns = 20) {
         null, // currentStep
         {
           steps,
+          stepsArchive,
           missionName,
+          retryLimit,
+          groundControl,
           onStep: (s) => {
             // Append each step as a JSON line
             try {
               fs.appendFileSync(stepFile, JSON.stringify(s) + '\n');
               // Keep memory in check: retain only the last ~20 steps in RAM
               if (steps.length > 20) steps.splice(0, steps.length - 20);
+              stepsArchive.push(s);
             } catch {} // best-effort; don’t crash the agent
           }
         }
       );
 
       function dedupeSteps(steps) {
-        const seen = new Set();
-        const out = [];
-        for (const s of steps) {
-          const first = s?.events?.[0] || '';
-          const key = `${s.turn}::${s.summary}::${first}`;
-          if (!seen.has(key)) {
-            seen.add(key);
-            out.push(s);
+        const copy = [...steps];
+        copy.sort((a, b) => {
+          if (Number.isFinite(a?._seq) && Number.isFinite(b?._seq)) {
+            return a._seq - b._seq;
           }
-        }
-        return out;
+          return (a?.turn ?? 0) - (b?.turn ?? 0);
+        });
+        return copy;
       }
 
-      const compact = dedupeSteps(steps);
+      const compact = dedupeSteps(stepsArchive.length ? stepsArchive : steps);
 
       // Snapshot steps (avoid retaining references to mutable arrays)
       missionResults.push({

package/core/config.js

@@ -52,6 +52,36 @@ export function getMaxTurns(cfg, fallback = 20) {
   return n;
 }
 
+/**
+ * Resolve retry limit per turn (attempts - 1) with clamping.
+ * Priority: env TESTRONAUT_RETRY_LIMIT → config.retryLimit → fallback
+ *
+ * @param {object} cfg
+ * @param {number} [fallback=2]
+ * @returns {{ value:number, source:'env'|'config'|'default', clamped:boolean }}
+ */
+export function getRetryLimit(cfg, fallback = 2) {
+  const clampRetry = (n) => {
+    const clamped = Math.min(10, Math.max(1, n));
+    return { value: clamped, clamped: clamped !== n };
+  };
+
+  const envVal = Number(process.env.TESTRONAUT_RETRY_LIMIT);
+  if (Number.isFinite(envVal)) {
+    const { value, clamped } = clampRetry(envVal);
+    return { value, source: 'env', clamped };
+  }
+
+  const cfgVal = Number(cfg?.retryLimit);
+  if (Number.isFinite(cfgVal)) {
+    const { value, clamped } = clampRetry(cfgVal);
+    return { value, source: 'config', clamped };
+  }
+
+  const { value, clamped } = clampRetry(fallback);
+  return { value, source: 'default', clamped };
+}
+
 /**
  * Baseline limits for mission runs. Adjust here for global defaults.
  *

package/core/turnLoop.js

@@ -47,6 +47,13 @@ import { resolveProviderModel } from '../llm/modelResolver.js';
 import { getLLM } from '../llm/llmFactory.js';
 import { summarizeTurnIntentFromMessage } from './turnIntent.js';
 import { redactArgs } from './redaction.js';
+import { 
+  sanitizeHeavyToolHistory, 
+  pruneConversationContext,
+  createEmptyGroundControl,
+  applyGroundControlUpdate,
+  recordGroundTelemetry,
+ } from '../tools/contextControl.js';
 
 // ─────────────────────────────────────────────
 // STEP 0: Resolve provider + model and initialize adapter
@@ -60,7 +67,28 @@ const llm = getLLM(PROVIDER_ID);
 let totalTokensUsed = 0;
 let turnTimestamps = [];
 let shouldBackoff;
-// let steps = [];
+const DEFAULT_TURN_RETRY_LIMIT = 2; // number of retries (not counting initial attempt)
+const TURN_RETRY_BASE_DELAY_MS = 500;
+
+// Certain tools mutate the browser or produce side effects that are
+// *useful for humans* (reports/screenshots), but do not carry semantic
+// information that the LLM needs on subsequent turns.
+// For these, we respond to the tool_call with a tiny stub ("OK"/error)
+// instead of the full result payload to avoid bloating context.
+//
+// NOTE: We *still* log the full result in `step.events` and step metadata.
+const FIRE_AND_FORGET_TOOLS = new Set([
+  'screenshot',
+  'click',
+  'click_text',
+  // 'expand_menu',
+  'fill',
+  'upload_file',
+  'download_file',
+  'click_and_follow_popup',
+  'switch_to_page',
+  'close_current_page',
+]);
 
 /**
  * Utility: format byte counts into human-readable strings.
@@ -143,17 +171,27 @@ export const turnLoop = async (
   currentTurn = 0, 
   retryCount = 0, 
   currentStep = {},
-  ctx = {} // { steps, missionName }
+  ctx = {} // { steps, missionName, groundControl }
 ) => {
-  const { steps = [], missionName } = ctx;
+  const { steps = [], missionName, groundControl = createEmptyGroundControl(), retryLimit: retryLimitRaw } = ctx;
+  const stepsArchive = ctx.stepsArchive || steps;
+  const retryLimitClamped = Math.min(10, Math.max(1, Number.isFinite(retryLimitRaw) ? retryLimitRaw : DEFAULT_TURN_RETRY_LIMIT)); // retries allowed (excludes initial)
+  const maxAttempts = retryLimitClamped + 1; // includes initial attempt
+  ctx.groundControl = groundControl;
   let agentMemory = { lastMenuExpanded: false };
+  let turnRetries = 0;
+  let stepSeq = ctx._stepSeq || 0;
   
   // Centralized recorder: push to in-memory buffer AND fire optional callback for streaming
   // Idempotent recorder – prevents accidental double-push
   const recordStep = (step) => {
     if (!step || step.__recorded) return;
+    step._seq = stepSeq++;
     step.__recorded = true;
     try { steps.push(step); } catch {}
+    if (stepsArchive && stepsArchive !== steps) {
+      try { stepsArchive.push(step); } catch {}
+    }
     try { ctx?.onStep?.(step); } catch {}
   };
   
@@ -163,7 +201,19 @@ export const turnLoop = async (
   for (let turn = currentTurn; turn < maxTurns; turn++) {
     console.log(`\n🔄 Turn ${turn + 1}/${maxTurns}`);
     let response;
-    const step = { turn, events: [], result: '🟡 In Progress', missionName };
+    const attempt = turnRetries + 1;
+    const step = {
+      turn,
+      retryAttempt: attempt,
+      retryLimit: retryLimitClamped, // number of retries allowed (excludes initial)
+      events: [],
+      result: '🟡 In Progress',
+      missionName,
+    };
+    if (attempt > 1) {
+      const retryNumber = attempt - 1;
+      step.events.push(`🔁 Re-attempt ${retryNumber}/${retryLimitClamped} for turn`);
+    }
 
     try {
       // Refresh token usage window (rolling 60 seconds)
@@ -173,11 +223,9 @@ export const turnLoop = async (
       ({ totalTokensUsed, turnTimestamps, shouldBackoff } =
         await tokenUseCoolOff(totalTokensUsed, turnTimestamps, MODEL_ID));
       if (shouldBackoff) {
-        // step.result = '🟡 In Progress';
         recordStep(step);         // ✅ write the partial step before sleeping
         turn -= 1;                // retry same turn index
         continue;
-        // return await turnLoop(browser, messages, maxTurns, turn, currentStep);
       }
 
       // Verify message structure integrity before requesting next model step
@@ -186,7 +234,7 @@ export const turnLoop = async (
         step.events.push('❌ Tool call structure invalid and no placeholders inserted.');
         step.result = '❌ Failure';
         recordStep(step);
-        return steps;
+        return { success: false, steps: stepsArchive };
       }
 
       // Detect orphaned assistant tool calls with no matching tool responses
@@ -206,9 +254,21 @@ export const turnLoop = async (
         step.events.push('🛑 Detected assistant tool calls without matching tool responses');
         step.result = '❌ Failure';
         recordStep(step);
-        return steps;
+        return { success: false, steps: stepsArchive };
       }
 
+      // Before calling the model, trim/sanitize the conversation context.
+      // 1) Replace older heavy tool payloads with small stubs.
+      sanitizeHeavyToolHistory(messages, { keepRecentPerTool: 2 });
+
+      // 2) Hard-cap total history length (system messages + last N others).
+      {
+        const pruned = pruneConversationContext(messages, { maxNonSystemMessages: 40 });
+        messages.length = 0;
+        messages.push(...pruned);
+      }
+
+
       // ─────────────────────────────────────────────
       // STEP 2: Request next reasoning turn from model
       // ─────────────────────────────────────────────
@@ -228,7 +288,6 @@ export const turnLoop = async (
         const delay = Math.min(60000, 2 ** retryCount * 2000);
         console.warn(`⚠️ Rate limited. Retrying in ${delay / 1000}s... (retry ${retryCount + 1})`);
         step.events.push(`⏳ Rate limit: waiting ${Math.round(delay/1000)}s (retry ${retryCount + 1})`);
-        // step.result = '🟡 In Progress';
         recordStep(step);         // ✅ persist this step before sleeping
         await wait(delay);
 
@@ -237,10 +296,8 @@ export const turnLoop = async (
           step.events.push('❌ Too many retries. Exiting.');
           step.result = '❌ Failure';
           recordStep(step);
-          return steps;
+          return { success: false, steps: stepsArchive };
         }
-        // return await turnLoop(browser, messages, maxTurns, turn, retryCount + 1, step);
-        // reattempt same turn after delay; keep same loop, bump retryCount
         retryCount += 1;
         turn -= 1;
         continue;
@@ -249,7 +306,7 @@ export const turnLoop = async (
         step.events.push(`❌ Bad request: ${err.message}`);
         step.result = '❌ Failure';
         recordStep(step);
-        return steps;
+        return { success: false, steps: stepsArchive };
       } else {
         throw err;
       }
@@ -285,6 +342,7 @@ export const turnLoop = async (
     if (msg.tool_calls?.length) {
       console.log('Processing tool calls...');
       const toolResponses = [];
+      let hadToolIssues = false;
 
       for (const call of msg.tool_calls) {
         const fnName = call.function.name;
@@ -301,9 +359,10 @@ export const turnLoop = async (
         } catch (e) {
           errorMessage = `ERROR: ${e.message}`;
           result = errorMessage;
+          hadToolIssues = true;
         }
 
-        // Capture and log any file upload/download events
+        // Capture and log any file upload/download events (for reports)
         try {
           const maybeJson = JSON.parse(result);
           if (maybeJson && maybeJson._testronaut_file_event) {
@@ -315,14 +374,16 @@ export const turnLoop = async (
             step.events.push(msgLine);
             console.log(msgLine);
           }
-        } catch { /* non-JSON results ignored */ }
+        } catch {
+          // non-JSON results ignored
+        }
 
         console.log(`[tool ] ← ${fnName} result:`, errorMessage ? '❌ Failed' : '✅ Success');
         const truncated = result.length > 1000 ? result.slice(0, 1000) + '…' : result;
         step.events.push(`[tool ] ← ${fnName} result: ${errorMessage ? '❌ Failed' : '✅ Success'}`);
         step.events.push(`[tool ] ← ${truncated}`);
 
-        // Screenshot detection
+        // Screenshot detection (for report metadata only)
         if (fnName === 'screenshot') {
           const match = result.match(/screenshot.*?saved at: (.+\.png)/i);
           if (match && match[1]) {
@@ -331,13 +392,33 @@ export const turnLoop = async (
           }
         }
 
-        // Push corresponding tool message back to LLM
+        if (fnName === 'set_ground_control_state') {
+          applyGroundControlUpdate(groundControl, args);
+          result = JSON.stringify({ ok: true, groundControl });
+        }
+
+        if (fnName === 'record_mission_telemetry') {
+          const recorded = recordGroundTelemetry(groundControl, args, { turn });
+          result = JSON.stringify({ ok: true, recorded });
+        }
+
+        // Decide what to send back to the LLM for this tool.
+        // - For "fire-and-forget" tools, send a tiny stub (OK/error) to avoid
+        //   bloating context with large payloads (file JSON, etc.).
+        // - For semantic tools (get_dom, check_text, etc.), send full result.
+        let contentForModel;
+        if (FIRE_AND_FORGET_TOOLS.has(fnName)) {
+          contentForModel = errorMessage || 'OK';
+        } else {
+          contentForModel = result;
+        }
+
         toolResponses.push({
           role: 'tool',
           tool_call_id: call.id,
           name: fnName,
           type: 'function',
-          content: result,
+          content: contentForModel,
         });
 
         // After interactive DOM actions, refresh model context
@@ -360,7 +441,21 @@ export const turnLoop = async (
 
       // Merge new assistant + tool responses back into conversation
       messages.push(msg, ...toolResponses);
-      step.result = '✅ Passed';
+      if (hadToolIssues && turnRetries < retryLimitClamped) {
+        step.result = '⏳ Retrying turn';
+        const retryNumber = attempt - 1;
+        step.events.push(`🔁 Re-attempt ${retryNumber}/${retryLimitClamped} after tool issues`);
+        recordStep(step);
+        turnRetries += 1;
+        const delay = Math.min(TURN_RETRY_BASE_DELAY_MS * 2 ** (turnRetries - 1), 2000);
+        await wait(delay);
+        turn -= 1; // re-use the same turn index
+        continue;
+      }
+
+      // reset retries after a clean turn or after exhausting retries
+      turnRetries = 0;
+      step.result = hadToolIssues ? '⚠️ Turn Issues' : '✅ Passed';
       recordStep(step);
       continue;
     }
@@ -373,7 +468,8 @@ export const turnLoop = async (
       step.events.push(finalResponse.finalMessage);
       step.result = finalResponse.success ? '✅ Mission Success' : '❌ Mission Failure';
       recordStep(step);
-      return { success: finalResponse.finalMessage, steps };
+      turnRetries = 0;
+      return { success: finalResponse.success, finalMessage: finalResponse.finalMessage, steps: stepsArchive };
     }
 
     // ─────────────────────────────────────────────
@@ -387,5 +483,8 @@ export const turnLoop = async (
     // This is a meaningful turn even without tool calls — record it.
     step.result = step.result || '🟡 In Progress';
     recordStep(step);
+    turnRetries = 0;
   }
+
+  return { success: false, steps: stepsArchive };
 };

package/llm/gemini/geminiProvider.js

@@ -109,6 +109,19 @@ function safeJsonParse(s) {
   try { return JSON.parse(s ?? '{}'); } catch { return null; }
 }
 
+// Gemini's functionDeclarations reject JSON Schema's `additionalProperties`; prune it recursively.
+function stripAdditionalProperties(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(stripAdditionalProperties);
+
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === 'additionalProperties') continue; // Gemini function declarations do not support this key
+    out[k] = stripAdditionalProperties(v);
+  }
+  return out;
+}
+
 /**
  * Convert a Gemini candidate → OpenAI-like assistant message.
  * - Collects text parts into `content`.
@@ -160,7 +173,7 @@ export class GeminiProvider {
           functionDeclarations: tools.map(t => ({
             name: t.function?.name ?? t.name,
             description: t.description ?? '',
-            parameters: t.function?.parameters ?? t.parameters ?? {}, // JSON schema
+            parameters: stripAdditionalProperties(t.function?.parameters ?? t.parameters ?? {}), // JSON schema sans additionalProperties (unsupported by Gemini)
           })),
         }]
       : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testronaut",
-  "version": "1.2.5",
+  "version": "1.3.1",
   "main": "./runner/testronaut.js",
   "bin": {
     "testronaut": "./bin/cli.js"