testronaut 1.2.2 → 1.2.4

package/bin/cli.js

@@ -1,4 +1,37 @@
 #!/usr/bin/env node
+
+/**
+ * cli.js
+ * -------
+ * Purpose:
+ *   Single entry point for the Testronaut CLI:
+ *   - Parses flags (e.g., --model, --turns, --init, help).
+ *   - Runs mission files (single or all), aggregates results, and writes HTML/JSON reports.
+ *   - Provides subcommands: login, upload (report + screenshots), serve/view (static file server).
+ *
+ * Key flags:
+ *   --model <id> / --model=<id>         → sets TESTRONAUT_MODEL env (wins over config file)
+ *   --turns <n> / --turns=<n>           → sets TESTRONAUT_TURNS env (wins over config file)
+ *   --init                               → scaffolds project + optional Playwright browsers
+ *   --help                               → prints help
+ *
+ * Notable helpers (defined below):
+ *   parseJsonSafe(res, label)            → tolerant JSON parse with good error messages
+ *   pkgManagerForCwd(cwd)                → detects npm/pnpm/yarn/bun
+ *   hasAny(modNames)                     → “do we have at least one of these deps?” (ESM-safe)
+ *   installDev(pm, pkg)                  → dev-install a package with the detected package manager
+ *   ensurePlaywrightInstalled()          → install @playwright/test and browsers (skippable in CI)
+ *   guessMimeType(p)                     → static server content types
+ *   safeJoin(root, relUrlPath)           → path traversal protection for static server
+ *   findLatestReportPair(reportDir)      → find latest run_<ts>.html (+ matching .json if present)
+ *   serveLatestReport()                  → read-only file server for most recent HTML report
+ *
+ * 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
+ */
+
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -18,7 +51,7 @@ import { ensureBrowsers } from '../tools/playwrightSetup.js';
 // Keep PW browsers inside the project to avoid global cache skew
 process.env.PLAYWRIGHT_BROWSERS_PATH = process.env.PLAYWRIGHT_BROWSERS_PATH || '0';
 
-
+const TMP_DIR = path.resolve('./missions/tmp');
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 // const apiBase = `http://localhost:3002` //
@@ -27,6 +60,52 @@ const apiBase = 'http://api.testronaut.app'; // Replace with your actual API bas
 
 const args = process.argv.slice(2);
 
+function readJsonlSteps(p) {
+  if (!p || !fs.existsSync(p)) return null;
+  const lines = fs.readFileSync(p, 'utf8').split(/\r?\n/).filter(Boolean);
+  const parsed = [];
+  for (const line of lines) {
+    try { parsed.push(JSON.parse(line)); } catch { /* ignore bad lines */ }
+  }
+  return parsed;
+}
+
+/**
+ * Merge duplicate turns without losing information.
+ * Strategy:
+ *  - Keep the latest **non-empty** version for a given turn if both exist
+ *  - If both are non-empty, keep the later one (last write wins)
+ *  - Preserve original order by line index as a tiebreaker
+ */
+function mergeDuplicateTurns(steps) {
+  const out = [];
+  const byTurn = new Map(); // turn -> index in out
+  for (const s of steps) {
+    const turn = Number.isFinite(s.turn) ? s.turn : out.length;
+    const hasEvents = Array.isArray(s.events) && s.events.length > 0;
+    if (!byTurn.has(turn)) {
+      out.push(s);
+      byTurn.set(turn, out.length - 1);
+    } else {
+      const idx = byTurn.get(turn);
+      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)
+      if (!existingHasEvents && hasEvents) {
+        out[idx] = s;
+      } else if (existingHasEvents && hasEvents) {
+        out[idx] = s;
+      } else {
+        // both empty or both sparse — keep latest
+        out[idx] = s;
+      }
+    }
+  }
+  // stable sort by `turn` ascending, then by original order via array index already preserved
+  out.sort((a, b) => (a.turn ?? 0) - (b.turn ?? 0));
+  return out;
+}
+
 // Look for --model=<id> or --model <id>
 let modelOverride;
 const modelFlagIndex = args.findIndex(a => a === '--model' || a.startsWith('--model='));
@@ -46,6 +125,29 @@ if (modelFlagIndex >= 0) {
   args.splice(modelFlagIndex, modelOverride ? 2 : 1);
 }
 
+// Look for --turns=<n> or --turns <n>
+let turnsOverride;
+const turnsFlagIndex = args.findIndex(a => a === '--turns' || a.startsWith('--turns='));
+if (turnsFlagIndex >= 0) {
+  if (args[turnsFlagIndex].includes('=')) {
+    turnsOverride = args[turnsFlagIndex].split('=')[1];
+  } else if (args[turnsFlagIndex + 1]) {
+    turnsOverride = args[turnsFlagIndex + 1];
+  }
+
+  if (turnsOverride) {
+    const n = Number(turnsOverride.trim());
+    if (Number.isFinite(n) && n > 0) {
+      process.env.TESTRONAUT_TURNS = String(n);
+      console.log(`🎯 Turn override: ${process.env.TESTRONAUT_TURNS}`);
+    } else {
+      console.warn(`⚠️ Invalid --turns value "${turnsOverride}". Ignoring.`);
+    }
+  }
+
+  // Remove flag & value so they aren’t treated as filenames
+  args.splice(turnsFlagIndex, turnsOverride ? 2 : 1);
+}
 
 const missionsDir = path.resolve(process.cwd(), 'missions');
 
@@ -66,6 +168,7 @@ Usage:
 
 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
 
 Examples:
@@ -179,11 +282,22 @@ const endTime = new Date();
 
 const flatMissions = allResults.flatMap(entry => {
   const result = entry.result;
-  const missions = Array.isArray(result) ? result : [result]; // normalize
-  return missions.map(m => ({
-    ...m,
-    file: entry.file
-  }));
+  const missions = Array.isArray(result) ? result : [result];
+
+  return missions.map(m => {
+    let steps = m.steps;
+    if (m.stepFile && fs.existsSync(m.stepFile)) {
+      const fromJsonl = readJsonlSteps(m.stepFile);
+      if (fromJsonl && fromJsonl.length) {
+        steps = mergeDuplicateTurns(fromJsonl);
+      }
+    }
+    return {
+      ...m,
+      steps,
+      file: entry.file,
+    };
+  });
 });
 
 // Read provider/model from config (allow env override for model)
@@ -228,7 +342,13 @@ fs.mkdirSync(outputDir, { recursive: true });
 fs.writeFileSync(`${outputDir}/${runId}.json`, JSON.stringify(report, null, 2));
 generateHtmlReport(report, `${outputDir}/${runId}.html`);
 
-// helpers near top of cli.js
+/**
+ * Parse a fetch Response safely and return JSON or throw a rich error.
+ * @param {Response} res
+ * @param {string} urlLabel - human-friendly label for error messages
+ * @returns {Promise<any>}
+ * @throws when HTTP status is not ok or body is empty/invalid
+ */
 async function parseJsonSafe(res, urlLabel) {
   const text = await res.text(); // read once
   let data = null;
@@ -248,6 +368,11 @@ async function parseJsonSafe(res, urlLabel) {
   return data;
 }
 
+/**
+ * Detect the local package manager based on lockfiles.
+ * @param {string} [cwd=process.cwd()]
+ * @returns {'pnpm'|'yarn'|'bun'|'npm'}
+ */
 function pkgManagerForCwd(cwd = process.cwd()) {
   const has = (f) => fs.existsSync(path.join(cwd, f));
   if (has('pnpm-lock.yaml')) return 'pnpm';
@@ -559,7 +684,11 @@ async function uploadReport() {
   }
 }
 
-
+/**
+ * Guess a reasonable MIME type for static serving.
+ * @param {string} p - file path
+ * @returns {string}
+ */
 function guessMimeType(p) {
   const ext = path.extname(p).toLowerCase();
   if (ext === '.html' || ext === '.htm') return 'text/html; charset=utf-8';
@@ -574,6 +703,12 @@ function guessMimeType(p) {
   return 'application/octet-stream';
 }
 
+/**
+ * Path-join a request path to a root directory with traversal protection.
+ * @param {string} root - filesystem directory
+ * @param {string} relUrlPath - URL path from incoming request
+ * @returns {string|null} resolved path or null on attempted escape
+ */
 function safeJoin(root, relUrlPath) {
   // Prevent path traversal and keep within root
   const decoded = decodeURIComponent(relUrlPath);
@@ -593,6 +728,12 @@ async function openInBrowser(targetUrl) {
   return exec(`xdg-open ${quoted}`).catch(() => {}); // best-effort on Linux
 }
 
+/**
+ * Find the latest run HTML (and its matching JSON, if present).
+ * Expects files like "run_<timestamp>.html" in the report directory.
+ * @param {string} reportDir
+ * @returns {{htmlFile:string, jsonFile:string|null}|null}
+ */
 function findLatestReportPair(reportDir) {
   if (!fs.existsSync(reportDir)) return null;
   const files = fs.readdirSync(reportDir).filter(f => f.endsWith('.html'));
@@ -691,3 +832,14 @@ async function serveLatestReport() {
   // Best-effort auto-open
   await openInBrowser(reportUrl).catch(() => {});
 }
+
+try {
+  if (!process.env.TN_KEEP_TMP && fs.existsSync(TMP_DIR)) {
+    fs.rmSync(TMP_DIR, { recursive: true, force: true });
+    console.log('🧹 Cleaned up temporary files.');
+  } else {
+    console.log('⚠️ Skipped tmp cleanup (TN_KEEP_TMP set).');
+  }
+} catch (err) {
+  console.warn(`⚠️ Could not remove tmp folder: ${err.message}`);
+}

package/core/agent.js

@@ -1,18 +1,67 @@
+/**
+ * agent.js
+ * --------
+ * Purpose:
+ *   Orchestrate a browser-backed autonomous agent over a sequence of goals.
+ *
+ * Responsibilities:
+ *   - Start/stop the browser lifecycle.
+ *   - For each goal, construct initial messages and invoke turnLoop().
+ *   - Collect per-goal traces into a normalized missionResults array.
+ *
+ * Message contract (initial):
+ *   messages = [
+ *     { role: 'system', content: 'instructions...' },
+ *     { role: 'user',   content: <goal text> }
+ *   ]
+ *
+ * Related tests:
+ *   tests/agentTests/agent.test.js
+ *
+ * Used by:
+ *   - cli/testronaut.js (runMissions)
+ */
+
 import 'dotenv/config';
 import { ChromeBrowser } from '../tools/chromeBrowser.js';
 import { turnLoop } from './turnLoop.js';
+import fs from 'fs';
+import path from 'path';
 
-export async function runAgent(goals, missionName, maxTurns = 20, ) {
+/**
+ * Execute goals with a browser agent.
+ *
+ * @param {Array<{goal:any, submissionType?:string, submissionName?:string, label?:string}>} goals
+ * @param {string} missionName
+ * @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) {
   const browser = new ChromeBrowser();
   await browser.start();
-  const startTime = Date.now();
   let result;
 
   try {
     const missionResults = [];
+    const tmpDir = path.resolve(process.cwd(), 'missions/tmp');
+    fs.mkdirSync(tmpDir, { recursive: true });
+
     for (const goal of goals) {
-      // console.log(`\n🚀 Running Agent with goal:\n${goal}\n`);
       const steps = [];
+      // Unique-ish JSONL file for this mission’s steps
+      const stepFile = path.join(
+        tmpDir,
+        `${missionName.replace(/[^\w.-]+/g, '_')}_${Date.now()}_steps.jsonl`
+      );
+      // Start clean
+      fs.writeFileSync(stepFile, '');
+
+      // Ensure user message is a string (functions/objects → toString fallback)
+      const userContent =
+        typeof goal.goal === 'string'
+          ? goal.goal
+          : goal?.goal?.toString?.() ?? String(goal.goal);
+
       const messages = [
         {
           role: 'system',
@@ -29,61 +78,67 @@ export async function runAgent(goals, missionName, maxTurns = 20, ) {
             After completing the goal, respond with a final plain-text message starting with SUCCESS or FAILURE.
           `.trim(),
         },
-        { role: 'user', content: goal.goal },
+        { role: 'user', content: userContent },
       ];
 
+      // Run the turn loop for this goal
       result = await turnLoop(
-        browser, 
-        messages, 
-        maxTurns, 
-        0, /* currentTurn */
-        0, /* retryCount */
-        null, /* currentStep */
+        browser,
+        messages,
+        maxTurns,
+        0,    // currentTurn
+        0,    // retryCount
+        null, // currentStep
         {
-          steps,          // 👈 pass in
-          missionName,    // 👈 pass in (for tagging)
+          steps,
+          missionName,
+          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);
+            } 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);
+          }
+        }
+        return out;
+      }
+
+      const compact = dedupeSteps(steps);
+
+      // Snapshot steps (avoid retaining references to mutable arrays)
       missionResults.push({
         missionName,
         submissionType: goal.submissionType || goal.label,
         submissionName: goal.submissionName || null,
         status: result?.success ? 'passed' : 'failed',
-        steps: JSON.parse(JSON.stringify(steps)), // 👈 deep-clone to avoid refs
-        startTime: Date.now() - 1, // set real values if you have them
+        steps: JSON.parse(JSON.stringify(compact)), // last 20 (by memory design)
+        stepFile, // full history is in this JSONL (one step per line)
+        startTime: Date.now() - 1, // TODO: wire actual timings if needed
         endTime: Date.now(),
       });
 
-      if (!result.success) {
+      if (!result?.success) {
         console.log('🛑 Agent stopped due to failed goal.\n');
         return missionResults;
       }
-
-      // if (!result.success) {
-      //   console.log('🛑 Agent stopped due to failed goal.\n');
-      //   const endTime = Date.now();
-      //   return {
-      //     missionName: missionName,
-      //     status: 'failed',
-      //     steps: result.steps,
-      //     startTime: startTime,
-      //     endTime: endTime,
-      //   };
-      // }
     }
 
     console.log('✅ All goals completed successfully.\n');
-    // const endTime = Date.now();
     return missionResults;
-    // return {
-    //   missionName: missionName,
-    //   status: 'passed',
-    //   steps: result.steps,
-    //   startTime: startTime,
-    //   endTime: endTime,
-    // };
-
   } finally {
     await browser.close();
   }

package/core/config.js

@@ -0,0 +1,146 @@
+/**
+ * config.js
+ * ----------
+ * Purpose:
+ *   Centralized config loading and turn-budget guardrails for Testronaut.
+ *
+ * Responsibilities:
+ *   - Load `testronaut-config.json` (best effort).
+ *   - Read specific knobs with safe fallbacks (e.g., maxTurns).
+ *   - Define baseline limits (soft/hard/min/idle/errors/time).
+ *   - Enforce user requests via clamp + warn (default) or fail-fast (strict).
+ *
+ * Related tests:
+ *   tests/configTests/config.test.js
+ *
+ * Used by:
+ *   - cli/testronaut.js (to derive effectiveMax turns per run)
+ *   - core/agent.js / core/turnLoop.js (runtime stop conditions)
+ */
+
+// core/config.js
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * Load testronaut-config.json from the given cwd.
+ * Returns {} when missing or invalid JSON.
+ *
+ * @param {string} [cwd=process.cwd()]
+ * @returns {Promise<object>}
+ */
+export async function loadConfig(cwd = process.cwd()) {
+  try {
+    const raw = await readFile(path.join(cwd, 'testronaut-config.json'), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    // No config or invalid JSON — fall back to defaults at call sites
+    return {};
+  }
+}
+
+/**
+ * Resolve the requested maxTurns from config with a safe fallback.
+ *
+ * @param {object} cfg
+ * @param {number} [fallback=20]
+ * @returns {number}
+ */
+export function getMaxTurns(cfg, fallback = 20) {
+  const n = Number(cfg?.maxTurns);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return n;
+}
+
+/**
+ * Baseline limits for mission runs. Adjust here for global defaults.
+ *
+ * @returns {{
+ *   softMaxTurns:number,
+ *   hardMaxTurns:number,
+ *   hardMinTurns:number,
+ *   maxIdleTurns:number,
+ *   maxErrors:number,
+ *   maxSeconds:number
+ * }}
+ */
+export function resolveTurnLimits() {
+  const softMaxTurns   = 50;
+  const hardMaxTurns   = 200;
+  const hardMinTurns   = 5;
+  const maxIdleTurns   = 6;
+  const maxErrors      = 5;
+  const maxSeconds     = 600; //10 minutes
+
+  return {
+    softMaxTurns,
+    hardMaxTurns,
+    hardMinTurns,
+    maxIdleTurns,
+    maxErrors,
+    maxSeconds,
+  };
+}
+
+/**
+ * Compute an effective turn budget and normalized limits from config.
+ * - Default: clamp + warn (lenient).
+ * - Strict mode (cfg.strictLimits or env STRICT_LIMITS): throw on violations.
+ *
+ * @param {object} cfg
+ * @param {ReturnType<typeof resolveTurnLimits>} [baseLimits=resolveTurnLimits()]
+ * @returns {{
+ *   effectiveMax:number,
+ *   limits: ReturnType<typeof resolveTurnLimits>,
+ *   notes:string[],
+ *   strict:boolean
+ * }}
+ */
+export function enforceTurnBudget(cfg, baseLimits = resolveTurnLimits()) {
+  const strict = !!(cfg?.strictLimits || process.env.STRICT_LIMITS);
+
+  const limits = { ...baseLimits };
+  const notes = [];
+
+  // Normalize soft/hard ordering
+  if (limits.softMaxTurns > limits.hardMaxTurns) {
+    if (strict) throw new Error(`[limits] softMaxTurns (${limits.softMaxTurns}) > hardMaxTurns (${limits.hardMaxTurns}).`);
+    notes.push(`Adjusted softMaxTurns down to hardMaxTurns (${limits.hardMaxTurns}).`);
+    limits.softMaxTurns = limits.hardMaxTurns;
+  }
+  if (limits.hardMinTurns > limits.softMaxTurns) {
+    if (strict) throw new Error(`[limits] hardMinTurns (${limits.hardMinTurns}) > softMaxTurns (${limits.softMaxTurns}).`);
+    notes.push(`Adjusted hardMinTurns down to softMaxTurns (${limits.softMaxTurns}).`);
+    limits.hardMinTurns = limits.softMaxTurns;
+  }
+
+  // Resolve requested maxTurns (env override wins over config)
+  const envTurns = Number(process.env.TESTRONAUT_TURNS);
+  const hasEnv = Number.isFinite(envTurns) && envTurns > 0;
+  const cfgTurns = Number(cfg?.maxTurns);
+  const hasCfg = Number.isFinite(cfgTurns) && cfgTurns > 0;
+  let requested = hasEnv ? envTurns : (hasCfg ? cfgTurns : 20);
+  let effectiveMax = requested;
+
+  if (hasEnv) {
+    notes.push(`ℹ️ Using CLI turn override (TESTRONAUT_TURNS=${envTurns}).`);
+  }
+
+  if (effectiveMax > limits.hardMaxTurns) {
+    const msg = `maxTurns (${effectiveMax}) exceeds hardMaxTurns (${limits.hardMaxTurns}).`;
+    if (strict) throw new Error(`[limits] ${msg}`);
+    notes.push(`⚠️ ${msg} Clamping to ${limits.hardMaxTurns}.`);
+    effectiveMax = limits.hardMaxTurns;
+  } else if (effectiveMax > limits.softMaxTurns) {
+    const msg = `maxTurns (${effectiveMax}) exceeds softMaxTurns (${limits.softMaxTurns}).`;
+    if (strict) throw new Error(`[limits] ${msg}`);
+    notes.push(`⚠️ ${msg} Proceeding, but consider lowering to control cost.`);
+  } else if (effectiveMax < limits.hardMinTurns) {
+    const msg = `maxTurns (${effectiveMax}) is below hardMinTurns (${limits.hardMinTurns}).`;
+    if (strict) throw new Error(`[limits] ${msg}`);
+    notes.push(`⚠️ ${msg} Raising to ${limits.hardMinTurns}.`);
+    effectiveMax = limits.hardMinTurns;
+  }
+
+  return { effectiveMax, limits, notes, strict };
+}

package/core/turnLoop.js

@@ -60,7 +60,7 @@ const llm = getLLM(PROVIDER_ID);
 let totalTokensUsed = 0;
 let turnTimestamps = [];
 let shouldBackoff;
-let steps = [];
+// let steps = [];
 
 /**
  * Utility: format byte counts into human-readable strings.
@@ -148,6 +148,15 @@ export const turnLoop = async (
   const { steps = [], missionName } = ctx;
   let agentMemory = { lastMenuExpanded: false };
   
+  // 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.__recorded = true;
+    try { steps.push(step); } catch {}
+    try { ctx?.onStep?.(step); } catch {}
+  };
+  
   // ─────────────────────────────────────────────
   // STEP 1: Begin reasoning cycle
   // ─────────────────────────────────────────────
@@ -163,7 +172,13 @@ export const turnLoop = async (
       // Adaptive cooldown if nearing provider rate limit
       ({ totalTokensUsed, turnTimestamps, shouldBackoff } =
         await tokenUseCoolOff(totalTokensUsed, turnTimestamps, MODEL_ID));
-      if (shouldBackoff) return await turnLoop(browser, messages, maxTurns, turn, currentStep);
+      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
       if (!validateAndInsertMissingToolResponses(messages, { insertPlaceholders: true })) {
@@ -171,6 +186,7 @@ export const turnLoop = async (
         step.events.push('❌ Tool call structure invalid and no placeholders inserted.');
         step.result = '❌ Failure';
         steps.push(step);
+        recordStep(step);
         return steps;
       }
 
@@ -191,6 +207,7 @@ export const turnLoop = async (
         step.events.push('🛑 Detected assistant tool calls without matching tool responses');
         step.result = '❌ Failure';
         steps.push(step);
+        recordStep(step);
         return steps;
       }
 
@@ -212,6 +229,9 @@ export const turnLoop = async (
         try { updateLimitsFromHeaders(MODEL_ID, err.headers || err.response?.headers || {}); } catch {}
         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);
 
         if (retryCount >= 5) {
@@ -219,14 +239,20 @@ export const turnLoop = async (
           step.events.push('❌ Too many retries. Exiting.');
           step.result = '❌ Failure';
           steps.push(step);
+          recordStep(step);
           return steps;
         }
-        return await turnLoop(browser, messages, maxTurns, turn, retryCount + 1, step);
+        // 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;
       } else if (err.status === 400) {
         console.error('❌ Bad request:', err.message);
         step.events.push(`❌ Bad request: ${err.message}`);
         step.result = '❌ Failure';
         steps.push(step);
+        recordStep(step);
         return steps;
       } else {
         throw err;
@@ -296,7 +322,7 @@ export const turnLoop = async (
         } catch { /* non-JSON results ignored */ }
 
         console.log(`[tool ] ← ${fnName} result:`, errorMessage ? '❌ Failed' : '✅ Success');
-        const truncated = result.length > 100 ? result.slice(0, 100) + '…' : result;
+        const truncated = result.length > 1000 ? result.slice(0, 1000) + '…' : result;
         step.events.push(`[tool ] ← ${fnName} result: ${errorMessage ? '❌ Failed' : '✅ Success'}`);
         step.events.push(`[tool ] ← ${truncated}`);
 
@@ -340,6 +366,7 @@ export const turnLoop = async (
       messages.push(msg, ...toolResponses);
       step.result = '✅ Passed';
       steps.push(step);
+      recordStep(step);
       continue;
     }
 
@@ -351,6 +378,7 @@ export const turnLoop = async (
       step.events.push(finalResponse.finalMessage);
       step.result = finalResponse.success ? '✅ Mission Success' : '❌ Mission Failure';
       steps.push(step);
+      recordStep(step);
       return { success: finalResponse.finalMessage, steps };
     }
 
@@ -362,5 +390,8 @@ export const turnLoop = async (
     });
     console.log(`[auto] → Injected DOM for next reasoning step`);
     step.events.push(`[auto] → Injected DOM for next reasoning step`);
+    // This is a meaningful turn even without tool calls — record it.
+    step.result = step.result || '🟡 In Progress';
+    recordStep(step);
   }
 };

package/package.json

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

package/runner/testronaut.js

@@ -1,27 +1,49 @@
-import { runAgent } from '../core/agent.js';
-import { redactPasswordInText } from '../core/redaction.js';
-// import { runSuite } from './suiteRunner.js';
-
-// const objectives = [];
-
-// export function mission(title, fn) {
-//   console.log(`\n🚀 Mission: ${title}`);
-//   fn();
-// }
-
-// export function objective(desc, workflow) {
-//   objectives.push({ name: desc, workflow });
-// }
-
-// export async function launch(preMissionSetup) {
-//   await runSuite(objectives, preMissionSetup);
-// }
-
+/**
+ * testronaut.js
+ * -------------
+ * Purpose:
+ *   High-level mission runner: normalize pre/main/post submissions,
+ *   compute a safe turn budget from config, and invoke the agent.
+ *
+ * Responsibilities:
+ *   - Read config once and derive turn limits via enforceTurnBudget().
+ *   - Build a normalized list of submissions with human-friendly names.
+ *   - Redact sensitive text when logging mission strings.
+ *   - Call runAgent(goals, missionName, maxTurns) and post-process status.
+ *
+ * Message contract (goal → initial messages inside agent):
+ *   - system: operational guidance + success/failure contract
+ *   - user:   the mission text (or coerced string)
+ *
+ * Related tests:
+ *   tests/missionTests/testronaut.test.js
+ *
+ * Used by:
+ *   - CLI entrypoint(s)
+ */
 
 
+import { runAgent } from '../core/agent.js';
+import { redactPasswordInText } from '../core/redaction.js';
+import { loadConfig, enforceTurnBudget } from '../core/config.js';
+
+/**
+ * Run a mission flow.
+ *
+ * @param {{ preMission?: any|any[], mission?: any|any[], postMission?: any|any[] }} params
+ * @param {string} missionName
+ */
 export async function runMissions({ preMission, mission, postMission }, missionName) {
-  const normalizeToArray = (x) => (Array.isArray(x) ? x : x ? [x] : []);
+  // 1) Config and turn budget (with guardrails)
+  const cfg = await loadConfig();
+  const { effectiveMax, limits, notes } = enforceTurnBudget(cfg);
+  const maxTurns = effectiveMax;
+  if (notes.length) {
+    console.warn(notes.join('\n'));
+  }
 
+  // 2) Normalize submissions
+  const normalizeToArray = (x) => (Array.isArray(x) ? x : x ? [x] : []);
   const pre  = normalizeToArray(preMission);
   const main = normalizeToArray(mission);
   const post = normalizeToArray(postMission);
@@ -100,7 +122,8 @@ export async function runMissions({ preMission, mission, postMission }, missionN
     })
   );
 
-  const success = await runAgent(goals, missionName);
+  // 3) Execute
+  const success = await runAgent(goals, missionName, maxTurns);
   if (!success) {
     console.log(`❌ Aborting after failed goal.`);
     return;

package/tests/coreTests/agent.test.js

@@ -0,0 +1,127 @@
+// tests/coreTests/agent.test.js
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// 1) Provide a constructable mock without using `vi` inside the factory.
+vi.mock('../../tools/chromeBrowser.js', () => {
+  function ChromeBrowser() {}
+  ChromeBrowser.prototype.start = async function () {};
+  ChromeBrowser.prototype.close = async function () {};
+  return { ChromeBrowser };
+});
+
+// Keep turnLoop simple; using vi is fine here (no factory-hoist issue)
+vi.mock('../../core/turnLoop.js', () => ({
+  turnLoop: vi.fn(),
+}));
+
+import { ChromeBrowser } from '../../tools/chromeBrowser.js';
+import { turnLoop } from '../../core/turnLoop.js';
+import { runAgent } from '../../core/agent.js';
+
+let startSpy, closeSpy;
+
+describe('core/agent.runAgent', () => {
+  beforeEach(() => {
+    // 2) Spy on prototype methods AFTER import time
+    startSpy = vi.spyOn(ChromeBrowser.prototype, 'start').mockResolvedValue();
+    closeSpy = vi.spyOn(ChromeBrowser.prototype, 'close').mockResolvedValue();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    startSpy.mockRestore();
+    closeSpy.mockRestore();
+  });
+
+  it('runs all goals and returns missionResults (all passed)', async () => {
+    turnLoop
+      .mockResolvedValueOnce({ success: true })
+      .mockResolvedValueOnce({ success: true });
+
+    const goals = [
+      { goal: 'Do A', submissionType: 'mission', submissionName: 'A' },
+      { goal: 'Do B', submissionType: 'mission', submissionName: 'B' },
+    ];
+
+    const res = await runAgent(goals, 'My Mission', 10);
+
+    // Browser lifecycle
+    expect(startSpy).toHaveBeenCalledTimes(1);
+    expect(closeSpy).toHaveBeenCalledTimes(1);
+
+    // turnLoop called once per goal and receives maxTurns
+    expect(turnLoop).toHaveBeenCalledTimes(2);
+    expect(turnLoop.mock.calls[0][2]).toBe(10);
+    expect(turnLoop.mock.calls[1][2]).toBe(10);
+
+    expect(res).toHaveLength(2);
+    expect(res[0].status).toBe('passed');
+    expect(res[1].status).toBe('passed');
+  });
+
+  it('stops early on first failure and returns partial results', async () => {
+    turnLoop.mockResolvedValueOnce({ success: false });
+
+    const res = await runAgent(
+      [
+        { goal: 'A', submissionType: 'mission', submissionName: 'A' },
+        { goal: 'B', submissionType: 'mission', submissionName: 'B' },
+      ],
+      'Fail Mission',
+      7
+    );
+
+    expect(turnLoop).toHaveBeenCalledTimes(1);
+    expect(res).toHaveLength(1);
+    expect(res[0].status).toBe('failed');
+  });
+
+  it('coerces non-string goal to string for the user message', async () => {
+    turnLoop.mockResolvedValueOnce({ success: true });
+
+    await runAgent([{ goal: { toString: () => 'coerced text' } }], 'Coerce', 5);
+
+    const messages = turnLoop.mock.calls[0][1];
+    expect(messages[1]).toEqual({ role: 'user', content: 'coerced text' });
+  });
+
+  it('deep-clones steps so external mutations do not leak', async () => {
+    turnLoop.mockImplementationOnce(async (browser, messages, maxTurns, ct, rc, cs, ctx) => {
+      ctx.steps.push({ result: 'SUCCESS: step1' });
+      return { success: true };
+    });
+
+    const res1 = await runAgent([{ goal: 'Check clone' }], 'Clone Test', 3);
+    res1[0].steps[0].result = 'TAMPERED';
+
+    turnLoop.mockImplementationOnce(async (browser, messages, maxTurns, ct, rc, cs, ctx) => {
+      ctx.steps.push({ result: 'SUCCESS: step2' });
+      return { success: true };
+    });
+
+    const res2 = await runAgent([{ goal: 'Check clone' }], 'Clone Test 2', 3);
+    expect(res1[0].steps[0].result).toBe('TAMPERED');
+    expect(res2[0].steps[0].result).toBe('SUCCESS: step2');
+  });
+
+  it('includes missionName and submission metadata in results', async () => {
+    turnLoop.mockResolvedValueOnce({ success: true });
+
+    const res = await runAgent(
+      [
+        {
+          goal: 'Meta',
+          submissionType: 'mission',
+          submissionName: 'MetaName',
+          label: 'legacy-label',
+        },
+      ],
+      'MetaMission',
+      4
+    );
+
+    expect(res[0].missionName).toBe('MetaMission');
+    expect(res[0].submissionType).toBe('mission');
+    expect(res[0].submissionName).toBe('MetaName');
+  });
+});

package/tests/coreTests/config.test.js

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node:fs/promises', () => ({
+  readFile: vi.fn(),
+}));
+
+import { readFile } from 'node:fs/promises';
+import {
+  loadConfig,
+  getMaxTurns,
+  resolveTurnLimits,
+  enforceTurnBudget,
+} from '../../core/config.js';
+
+describe('core/config', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    delete process.env.STRICT_LIMITS;
+  });
+
+  describe('loadConfig', () => {
+    it('parses JSON when present', async () => {
+      readFile.mockResolvedValueOnce(JSON.stringify({ maxTurns: 33 }));
+      const cfg = await loadConfig('/any');
+      expect(cfg).toEqual({ maxTurns: 33 });
+    });
+
+    it('returns {} on ENOENT', async () => {
+      readFile.mockRejectedValueOnce(new Error('ENOENT'));
+      const cfg = await loadConfig('/missing');
+      expect(cfg).toEqual({});
+    });
+
+    it('returns {} on invalid JSON', async () => {
+      readFile.mockResolvedValueOnce('{ nope ');
+      const cfg = await loadConfig('/bad');
+      expect(cfg).toEqual({});
+    });
+  });
+
+  describe('getMaxTurns', () => {
+    it('uses fallback when invalid or missing', () => {
+      expect(getMaxTurns({}, 20)).toBe(20);
+      expect(getMaxTurns({ maxTurns: 'x' }, 20)).toBe(20);
+      expect(getMaxTurns({ maxTurns: 0 }, 20)).toBe(20);
+      expect(getMaxTurns({ maxTurns: -5 }, 20)).toBe(20);
+    });
+
+    it('returns numeric when valid', () => {
+      expect(getMaxTurns({ maxTurns: 7 }, 20)).toBe(7);
+      expect(getMaxTurns({ maxTurns: '15' }, 20)).toBe(15);
+    });
+  });
+
+  describe('resolveTurnLimits', () => {
+    it('returns expected defaults', () => {
+      const l = resolveTurnLimits();
+      expect(l.softMaxTurns).toBe(50);
+      expect(l.hardMaxTurns).toBe(200);
+      expect(l.hardMinTurns).toBe(5);
+      expect(l.maxIdleTurns).toBe(6);
+      expect(l.maxErrors).toBe(5);
+      expect(l.maxSeconds).toBe(600);
+    });
+  });
+
+  describe('enforceTurnBudget (lenient)', () => {
+    it('clamps > hardMaxTurns', () => {
+      const cfg = { maxTurns: 1000 };
+      const { effectiveMax, limits, notes, strict } = enforceTurnBudget(cfg);
+      expect(strict).toBe(false);
+      expect(effectiveMax).toBe(limits.hardMaxTurns);
+      expect(notes.join('\n')).toMatch(/Clamping to/i);
+    });
+
+    it('warns when > softMaxTurns but <= hardMaxTurns', () => {
+      const cfg = { maxTurns: 120 };
+      const { effectiveMax, limits, notes } = enforceTurnBudget(cfg);
+      expect(effectiveMax).toBe(120);
+      expect(notes.join('\n')).toMatch(/exceeds softMaxTurns/i);
+      expect(effectiveMax).toBeLessThanOrEqual(limits.hardMaxTurns);
+    });
+
+    it('raises to hardMinTurns when below minimum', () => {
+      const cfg = { maxTurns: 1 };
+      const { effectiveMax, limits, notes } = enforceTurnBudget(cfg);
+      expect(effectiveMax).toBe(limits.hardMinTurns);
+      expect(notes.join('\n')).toMatch(/Raising to/i);
+    });
+
+    it('normalizes soft>hard ordering with a note', () => {
+      const weird = {
+        softMaxTurns: 300,
+        hardMaxTurns: 200,
+        hardMinTurns: 5,
+        maxIdleTurns: 6,
+        maxErrors: 5,
+        maxSeconds: 600,
+      };
+      const { limits, notes } = enforceTurnBudget({ maxTurns: 20 }, weird);
+      expect(limits.softMaxTurns).toBe(limits.hardMaxTurns);
+      expect(notes.join('\n')).toMatch(/Adjusted softMaxTurns down to hardMaxTurns/);
+    });
+  });
+
+  describe('enforceTurnBudget (strict)', () => {
+    it('throws when > hardMaxTurns', () => {
+      const cfg = { maxTurns: 999, strictLimits: true };
+      expect(() => enforceTurnBudget(cfg)).toThrow(/exceeds hardMaxTurns/i);
+    });
+
+    it('throws when below hardMinTurns', () => {
+      process.env.STRICT_LIMITS = '1';
+      const cfg = { maxTurns: 2 };
+      expect(() => enforceTurnBudget(cfg)).toThrow(/below hardMinTurns/i);
+    });
+
+    it('throws when softMaxTurns > hardMaxTurns', () => {
+      const bad = {
+        softMaxTurns: 300,
+        hardMaxTurns: 200,
+        hardMinTurns: 5,
+        maxIdleTurns: 6,
+        maxErrors: 5,
+        maxSeconds: 600,
+      };
+      expect(() => enforceTurnBudget({ strictLimits: true, maxTurns: 20 }, bad))
+        .toThrow(/softMaxTurns .* > hardMaxTurns/);
+    });
+  });
+
+
+    describe('enforceTurnBudget env override', () => {
+    const old = process.env.TESTRONAUT_TURNS;
+
+    beforeEach(() => { delete process.env.TESTRONAUT_TURNS; });
+    afterEach(() => { if (old === undefined) delete process.env.TESTRONAUT_TURNS; else process.env.TESTRONAUT_TURNS = old; });
+
+    it('uses TESTRONAUT_TURNS over cfg.maxTurns', () => {
+        process.env.TESTRONAUT_TURNS = '30';
+        const { effectiveMax, notes } = enforceTurnBudget({ maxTurns: 5 });
+        expect(effectiveMax).toBe(30);
+        expect(notes.join('\n')).toMatch(/CLI turn override/i);
+    });
+    });
+});

package/tests/runnerTests/testronaut.test.js

@@ -0,0 +1,164 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mocks
+vi.mock('../../core/agent.js', () => ({ runAgent: vi.fn() }));
+vi.mock('../../core/redaction.js', () => ({
+  // simple deterministic redaction stub
+  redactPasswordInText: (s) => String(s).replace(/password:\s*\S+/gi, 'password: ********'),
+}));
+vi.mock('../../core/config.js', () => ({
+  loadConfig: vi.fn(),
+  enforceTurnBudget: vi.fn(),
+}));
+
+import { runAgent } from '../../core/agent.js';
+import { loadConfig, enforceTurnBudget } from '../../core/config.js';
+
+// Adjust the import path if your file lives elsewhere
+import { runMissions } from '../../runner/testronaut.js';
+
+describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('passes effectiveMax to runAgent and logs any notes', async () => {
+    loadConfig.mockResolvedValue({ maxTurns: 999 });
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 200,
+      limits: { softMaxTurns: 50, hardMaxTurns: 200, hardMinTurns: 5 },
+      notes: ['⚠️ maxTurns (999) exceeds hardMaxTurns (200). Clamping to 200.'],
+      strict: false,
+    });
+
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    runAgent.mockResolvedValue([
+      { steps: [{ result: 'SUCCESS: done' }], status: 'passed' },
+    ]);
+
+    await runMissions({ mission: 'Do xyz' }, 'Budgeted Run');
+
+    expect(loadConfig).toHaveBeenCalledTimes(1);
+    expect(enforceTurnBudget).toHaveBeenCalledWith({ maxTurns: 999 });
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('Clamping to 200')
+    );
+    expect(runAgent).toHaveBeenCalledWith(
+      expect.any(Array), 'Budgeted Run', 200
+    );
+
+    warn.mockRestore();
+    log.mockRestore();
+  });
+
+  it('does not warn when no notes are returned', async () => {
+    loadConfig.mockResolvedValue({ maxTurns: 20 });
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 20,
+      limits: { softMaxTurns: 50, hardMaxTurns: 200, hardMinTurns: 5 },
+      notes: [],
+      strict: false,
+    });
+
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    runAgent.mockResolvedValue([
+      { steps: [{ result: 'SUCCESS: ok' }], status: 'passed' },
+    ]);
+
+    await runMissions({ mission: 'No warnings' }, 'Clean');
+
+    expect(warn).not.toHaveBeenCalled();
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Clean', 20);
+
+    warn.mockRestore();
+    log.mockRestore();
+  });
+
+  it('marks first mission failed when last step result includes "failure"', async () => {
+    loadConfig.mockResolvedValue({});
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 20,
+      limits: {},
+      notes: [],
+      strict: false,
+    });
+
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    runAgent.mockResolvedValue([
+      { steps: [{ result: 'FAILURE: could not do it' }], status: 'passed' },
+    ]);
+
+    const res = await runMissions({ mission: 'Will fail' }, 'Status');
+    expect(res[0].status).toBe('failed');
+
+    log.mockRestore();
+  });
+
+  it('normalizes single strings and functions into arrays and names missions', async () => {
+    loadConfig.mockResolvedValue({});
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 15,
+      limits: {},
+      notes: [],
+      strict: false,
+    });
+
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    runAgent.mockResolvedValue([
+      { steps: [{ result: 'SUCCESS: done' }], status: 'passed' },
+    ]);
+
+    function preTask() {}
+    function postTask() {}
+
+    await runMissions(
+      {
+        preMission: preTask,
+        mission: 'Main mission text\nwith details',
+        postMission: postTask,
+      },
+      'My Mission'
+    );
+
+    // Check that runAgent got 3 goals (pre/main/post)
+    const call = (runAgent.mock.calls[0] || []);
+    const goals = call[0];
+    expect(Array.isArray(goals)).toBe(true);
+    expect(goals).toHaveLength(3);
+
+    // Submission types and names are set
+    expect(goals[0].submissionType).toBe('premission');
+    expect(goals[1].submissionType).toBe('mission');
+    expect(goals[2].submissionType).toBe('postmission');
+
+    // Mission name is the passed-in missionName for main
+    expect(goals[1].submissionName).toMatch(/^My Mission/);
+
+    // Effective max turns passed through
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15);
+
+    log.mockRestore();
+  });
+
+  it('aborts early when runAgent returns falsy (defensive)', async () => {
+    loadConfig.mockResolvedValue({});
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 10,
+      limits: {},
+      notes: [],
+      strict: false,
+    });
+
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    runAgent.mockResolvedValue(null); // simulate unexpected falsy
+
+    const res = await runMissions({ mission: 'Edge case' }, 'Abort');
+    expect(res).toBeUndefined();
+
+    log.mockRestore();
+  });
+});