testronaut 1.3.1 → 1.3.2

package/README.md

@@ -178,6 +178,8 @@ Each includes:
 - **LLMs** for reasoning, DOM parsing, and tool use  
 - **Token throttling** + adaptive cooldowns  
 - **Extensible architecture** for custom tools and workflows  
+- **DOM trimming controls** to cap list sizes (env `TESTRONAUT_DOM_LIST_LIMIT` or config `dom.listItemLimit`; use `all` cautiously—it can spike token use)
+- **Resource guard** to ensure full list/table downloads (config `resourceGuard` or env `TESTRONAUT_RESOURCE_*`)
 
 ---
 

package/bin/cli.js

@@ -47,6 +47,7 @@ import { promisify } from 'util';
 const exec = promisify(execCmd);
 import url from 'url';
 import { ensureBrowsers } from '../tools/playwrightSetup.js';
+import { discoverMissionFiles } from '../core/missionDiscovery.js';
 
 // Keep PW browsers inside the project to avoid global cache skew
 process.env.PLAYWRIGHT_BROWSERS_PATH = process.env.PLAYWRIGHT_BROWSERS_PATH || '0';
@@ -153,6 +154,48 @@ if (modelFlagIndex >= 0) {
   args.splice(modelFlagIndex, modelOverride ? 2 : 1);
 }
 
+// Look for --debug / --debug=<bool> / --no-debug
+// Normalize CLI boolean strings into true/false/null for optional flags.
+const parseBool = (v) => {
+  const lower = String(v ?? '').trim().toLowerCase();
+  if (!lower) return null;
+  if (['1', 'true', 'yes', 'on'].includes(lower)) return true;
+  if (['0', 'false', 'no', 'off'].includes(lower)) return false;
+  return null;
+};
+__test__.parseBool = parseBool;
+
+let debugOverride;
+let debugConsumesNext = false;
+const debugFlagIndex = args.findIndex(a =>
+  a === '--debug' ||
+  a.startsWith('--debug=') ||
+  a === '--no-debug'
+);
+if (debugFlagIndex >= 0) {
+  const rawArg = args[debugFlagIndex];
+  if (rawArg.includes('=')) {
+    debugOverride = parseBool(rawArg.split('=')[1]);
+  } else if (rawArg === '--no-debug') {
+    debugOverride = false;
+  } else if (args[debugFlagIndex + 1] && !args[debugFlagIndex + 1].startsWith('-')) {
+    debugOverride = parseBool(args[debugFlagIndex + 1]);
+    debugConsumesNext = true;
+  } else {
+    debugOverride = true; // bare --debug enables it
+  }
+
+  if (debugOverride !== null) {
+    process.env.TESTRONAUT_DEBUG = debugOverride ? '1' : '0';
+    console.log(`🛠️ Debug mode ${debugOverride ? 'enabled' : 'disabled'} (TESTRONAUT_DEBUG=${process.env.TESTRONAUT_DEBUG})`);
+  } else {
+    console.warn('⚠️ Invalid --debug value. Use true/false, 1/0, yes/no.');
+  }
+
+  const consume = 1 + (debugConsumesNext && debugOverride !== null ? 1 : 0);
+  args.splice(debugFlagIndex, consume);
+}
+
 // Look for --turns=<n> or --turns <n>
 let turnsOverride;
 const turnsFlagIndex = args.findIndex(a => a === '--turns' || a.startsWith('--turns='));
@@ -208,8 +251,6 @@ if (retryFlagIndex >= 0) {
   args.splice(retryFlagIndex, retryOverride ? 2 : 1);
 }
 
-const missionsDir = path.resolve(process.cwd(), 'missions');
-
 const allResults = [];
 const runId = `run_${Date.now()}`;
 const startTime = new Date();
@@ -228,6 +269,7 @@ Usage:
 Options:
   --init                    Scaffold project folders and a welcome mission
   --turns=<n>               Override max turns for this run (e.g., --turns=30)
+  --debug[=<bool>]          Enable verbose debug logs (or set TESTRONAUT_DEBUG=1)
   --help                    Show this help message
   --retry_limit=<n>         Override agent turn retry limits (minimum 1, maximum 10)
 
@@ -302,14 +344,16 @@ if (args.includes('serve') || args.includes('view')) {
   await new Promise(() => {}); // ✅ never resolves; Ctrl+C will terminate
 }
 
-if (!fs.existsSync(missionsDir)) {
-  console.error('❌ No `missions` directory found.');
+const { root: missionsRoot, files: discoveredMissions } = await discoverMissionFiles({ cwd: process.cwd() });
+
+if (!fs.existsSync(missionsRoot)) {
+  console.error(`❌ Missions directory not found: ${path.relative(process.cwd(), missionsRoot)}`);
   process.exit(1);
 }
 
 const runFile = async (filePath) => {
   try {
-    const modulePath = path.resolve(missionsDir, filePath);
+    const modulePath = path.resolve(missionsRoot, filePath);
     const missionsModule = await import(`file://${modulePath}`);
 
     if (typeof missionsModule.executeMission === 'function') {
@@ -331,9 +375,8 @@ if (args.length > 0) {
     await runFile(file);
   }
 } else {
-  // Run all *.mission.js files
-  const files = fs.readdirSync(missionsDir).filter(f => f.endsWith('.mission.js'));
-  for (const file of files) {
+  // Run missions discovered from config (or default behavior)
+  for (const file of discoveredMissions) {
     await runFile(file);
   }
 }

package/bin/init.js

@@ -139,6 +139,8 @@ export async function initializeTestronautProject() {
     config.outputDir = config.outputDir || defaults.outputDir;
     config.projectName = config.projectName || defaults.projectName;
     config.maxTurns = config.maxTurns ?? defaults.maxTurns;
+    config.dom = { ...defaults.dom, ...(config.dom || {}) };
+    config.resourceGuard = { ...defaults.resourceGuard, ...(config.resourceGuard || {}) };
 
     // ─────────────────────────────────────────────
     // STEP 4: Persist config and scaffold .env (first run only)

package/bin/initHelpers.js

@@ -52,6 +52,14 @@ export function defaultConfig(rootBasename) {
     outputDir: 'missions/mission_reports',
     projectName: rootBasename,
     maxTurns: 20,
+    dom: {
+      listItemLimit: 3,
+    },
+    resourceGuard: {
+      enabled: true,
+      hrefIncludes: ['/document/', '/file/', '/download', '/attachment/'],
+      dataTypes: ['document', 'file', 'item', 'row'],
+    },
   };
 }
 

package/core/agent.js

@@ -35,10 +35,16 @@ import path from 'path';
  * @param {Array<{goal:any, submissionType?:string, submissionName?:string, label?:string}>} goals
  * @param {string} missionName
  * @param {number} [maxTurns=20] - upper bound for turnLoop per goal
+ * @param {number} [retryLimit]
+ * @param {{ domListLimit?: number|typeof Infinity, debug?: boolean, resourceGuard?: { enabled:boolean, hrefIncludes:string[], dataTypes:string[] } }} [opts]
  * @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, retryLimit) {
-  const browser = new ChromeBrowser();
+export async function runAgent(goals, missionName, maxTurns = 20, retryLimit, opts = {}) {
+  const browser = new ChromeBrowser({
+    domListLimit: opts.domListLimit,
+    debug: opts.debug,
+    resourceGuard: opts.resourceGuard,
+  });
   await browser.start();
   let result;
 
@@ -155,8 +161,9 @@ Use Ground Control as your persistent mission memory about:
           steps,
           stepsArchive,
           missionName,
-          retryLimit,
+          retryLimit, 
           groundControl,
+          resourceGuard: opts.resourceGuard,
           onStep: (s) => {
             // Append each step as a JSON line
             try {

package/core/config.js

@@ -82,6 +82,97 @@ export function getRetryLimit(cfg, fallback = 2) {
   return { value, source: 'default', clamped };
 }
 
+/**
+ * Resolve how many list-like items to keep in DOM snapshots.
+ * - Accepts numbers (clamped 0-100), or the strings "all"/"none".
+ * - Priority: env TESTRONAUT_DOM_LIST_LIMIT → config.dom.listItemLimit/listLimit/domListLimit → fallback.
+ *
+ * @param {object} cfg
+ * @param {number} [fallback=3]
+ * @returns {{ value:number|typeof Infinity, mode:'number'|'all'|'none', source:'env'|'config'|'default', clamped:boolean }}
+ */
+export function getDomListLimit(cfg, fallback = 3) {
+  const clampList = (n) => {
+    const clamped = Math.min(100, Math.max(0, n));
+    return { value: clamped, clamped: clamped !== n };
+  };
+
+  const parseRaw = (raw) => {
+    if (raw === undefined || raw === null) return null;
+
+    if (typeof raw === 'string') {
+      const lower = raw.trim().toLowerCase();
+      if (!lower) return null;
+      if (lower === 'all') return { value: Infinity, mode: 'all', clamped: false };
+      if (lower === 'none') return { value: 0, mode: 'none', clamped: false };
+      const num = Number(lower);
+      if (!Number.isFinite(num)) return null;
+      const { value, clamped } = clampList(num);
+      return { value, mode: value === 0 ? 'none' : 'number', clamped };
+    }
+
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+      const { value, clamped } = clampList(raw);
+      return { value, mode: value === 0 ? 'none' : 'number', clamped };
+    }
+
+    return null;
+  };
+
+  const envParsed = parseRaw(process.env.TESTRONAUT_DOM_LIST_LIMIT);
+  if (envParsed) return { ...envParsed, source: 'env' };
+
+  const cfgRaw = cfg?.dom?.listItemLimit ?? cfg?.dom?.listLimit ?? cfg?.domListLimit;
+  const cfgParsed = parseRaw(cfgRaw);
+  if (cfgParsed) return { ...cfgParsed, source: 'config' };
+
+  const fbParsed = parseRaw(fallback);
+  return { ...fbParsed, source: 'default' };
+}
+
+/**
+ * Resolve resource guard settings for generic list/table harvesting.
+ * - Patterns are used to detect resource anchors/data attributes.
+ * - Enabled can be toggled via config.resourceGuard.enabled or TESTRONAUT_RESOURCE_GUARD.
+ */
+export function getResourceGuardConfig(cfg) {
+  const parseBool = (raw) => {
+    if (raw === undefined || raw === null) return null;
+    const lower = String(raw).trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(lower)) return true;
+    if (['0', 'false', 'no', 'off'].includes(lower)) return false;
+    return null;
+  };
+
+  const defaultHrefPatterns = ['/document/', '/file/', '/download', '/attachment/'];
+  const defaultDataTypes = ['document', 'file', 'item', 'row'];
+
+  const envEnabled = parseBool(process.env.TESTRONAUT_RESOURCE_GUARD);
+  const cfgEnabled = parseBool(cfg?.resourceGuard?.enabled);
+  const enabled = envEnabled ?? cfgEnabled ?? true;
+
+  const parseList = (raw) => {
+    if (Array.isArray(raw)) return raw.map(String).map(s => s.trim()).filter(Boolean);
+    if (typeof raw === 'string') {
+      return raw.split(',').map(s => s.trim()).filter(Boolean);
+    }
+    return [];
+  };
+
+  const hrefIncludes = parseList(process.env.TESTRONAUT_RESOURCE_HREF_PATTERNS)
+    || [];
+  const dataTypes = parseList(process.env.TESTRONAUT_RESOURCE_DATA_TYPES)
+    || [];
+
+  const cfgHref = parseList(cfg?.resourceGuard?.hrefIncludes);
+  const cfgTypes = parseList(cfg?.resourceGuard?.dataTypes);
+
+  const finalHref = (hrefIncludes.length ? hrefIncludes : cfgHref.length ? cfgHref : defaultHrefPatterns).map(s => s.toLowerCase());
+  const finalTypes = (dataTypes.length ? dataTypes : cfgTypes.length ? cfgTypes : defaultDataTypes).map(s => s.toLowerCase());
+
+  return { enabled, hrefIncludes: finalHref, dataTypes: finalTypes };
+}
+
 /**
  * Baseline limits for mission runs. Adjust here for global defaults.
  *

package/core/missionDiscovery.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+import fg from 'fast-glob';
+import { loadConfig } from './config.js';
+
+const DEFAULT_ROOT = 'missions';
+const DEFAULT_INCLUDE = ['**/*.mission.js', '**/*.mission.ts'];
+
+/**
+ * Discover mission files based on testronaut-config.json.
+ * - When no missions block exists, preserve legacy behavior:
+ *   read the ./missions folder (non-recursive) for *.mission.js files.
+ * - When missions is defined, apply root/include/exclude globs relative to root.
+ *
+ * @param {object} opts
+ * @param {string} [opts.cwd=process.cwd()] - project root for config + resolution
+ * @returns {Promise<{ root:string, files:string[] }>} root is absolute; files are relative to root
+ */
+export async function discoverMissionFiles({ cwd = process.cwd() } = {}) {
+  const defaultRoot = path.resolve(cwd, DEFAULT_ROOT);
+  const cfg = await loadConfig(cwd);
+  const missionsCfg = cfg?.missions;
+
+  // Legacy behavior: no missions block → non-recursive *.mission.js in ./missions
+  if (!missionsCfg) {
+    if (!fs.existsSync(defaultRoot)) {
+      return { root: defaultRoot, files: [] };
+    }
+    const files = fs.readdirSync(defaultRoot)
+      .filter(f => f.endsWith('.mission.js'))
+      .sort();
+    return { root: defaultRoot, files };
+  }
+
+  const root = path.resolve(cwd, missionsCfg.root || DEFAULT_ROOT);
+  if (!fs.existsSync(root)) {
+    return { root, files: [] };
+  }
+
+  const include = Array.isArray(missionsCfg.include) && missionsCfg.include.length
+    ? missionsCfg.include
+    : DEFAULT_INCLUDE;
+  const exclude = Array.isArray(missionsCfg.exclude) ? missionsCfg.exclude : [];
+
+  const matches = await fg(include, {
+    cwd: root,
+    ignore: exclude,
+    onlyFiles: true,
+  });
+
+  const unique = Array.from(new Set(matches));
+  unique.sort();
+
+  return { root, files: unique };
+}

package/core/turnLoop.js

@@ -63,6 +63,50 @@ console.log(`🧠 Using LLM → provider: ${PROVIDER_ID}, model: ${MODEL_ID}`);
 
 const llm = getLLM(PROVIDER_ID);
 
+// Track resource/download coverage across turns (guard against partial loops).
+function ensureDocProgress(agentMemory, cfg) {
+  if (!cfg?.enabled) return null;
+  if (!agentMemory.docProgress) {
+    agentMemory.docProgress = {
+      items: [],
+      downloaded: new Set(),
+      lastSummary: '',
+      lastScriptCount: 0,
+      patterns: cfg,
+    };
+  } else {
+    agentMemory.docProgress.patterns = cfg;
+  }
+  return agentMemory.docProgress;
+}
+
+// Parse injected <pre data-testronaut-doc-list> summary into structured items.
+function parseDocListFromDom(html) {
+  try {
+    const match = html.match(/<pre[^>]*data-testronaut-doc-list[^>]*>([\s\S]*?)<\/pre>/i);
+    if (!match) return { items: [], scriptDocs: 0 };
+    const text = match[1];
+    const lines = text.split('\n').map(l => l.trim()).filter(Boolean).slice(1);
+    const items = lines.map(l => {
+      const m = l.match(/-\s*\[(.*?)\]\s*(.*?)\s+(\/document\/\d+[^\s]*)?/i);
+      return {
+        id: m?.[1] || '',
+        title: m?.[2] || l.replace(/^-/, '').trim(),
+        href: m?.[3] || '',
+      };
+    }).filter(it => it.id || it.title || it.href);
+    return { items, scriptDocs: items.length };
+  } catch {
+    return { items: [], scriptDocs: 0 };
+  }
+}
+
+// Extract numeric document IDs from common /document/<id> URLs.
+function extractDocIdFromUrl(url = '') {
+  const m = url.match(/\/document\/(\d+)/i);
+  return m ? m[1] : '';
+}
+
 // Rolling token counters used for self-throttling
 let totalTokensUsed = 0;
 let turnTimestamps = [];
@@ -174,11 +218,17 @@ export const turnLoop = async (
   ctx = {} // { steps, missionName, groundControl }
 ) => {
   const { steps = [], missionName, groundControl = createEmptyGroundControl(), retryLimit: retryLimitRaw } = ctx;
+  const resourceGuardCfg = ctx.resourceGuard || {
+    enabled: true,
+    hrefIncludes: ['/document/', '/file/', '/download', '/attachment/'],
+    dataTypes: ['document', 'file', 'item', 'row'],
+  };
   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 };
+  ensureDocProgress(agentMemory, resourceGuardCfg);
   let turnRetries = 0;
   let stepSeq = ctx._stepSeq || 0;
   
@@ -373,6 +423,20 @@ export const turnLoop = async (
               : `📥 Downloaded "${maybeJson.fileName}" (${formatBytes(maybeJson.bytes)}) via ${maybeJson.mode}`;
             step.events.push(msgLine);
             console.log(msgLine);
+
+            if (resourceGuardCfg.enabled && (maybeJson._testronaut_file_event === 'download' || maybeJson._testronaut_file_event === 'upload')) {
+              const prog = ensureDocProgress(agentMemory, resourceGuardCfg);
+              if (prog) {
+                const id = extractDocIdFromUrl(maybeJson.url || maybeJson.selector || maybeJson.fileName);
+                if (id) prog.downloaded.add(id);
+                // also try title match
+                if (maybeJson.fileName) {
+                  const byTitle = prog.items.find(i => maybeJson.fileName.includes(i.title));
+                  if (byTitle?.id) prog.downloaded.add(byTitle.id);
+                }
+                step.events.push(`📊 Resource progress: ${prog.downloaded.size}/${prog.items.length || prog.lastScriptCount}`);
+              }
+            }
           }
         } catch {
           // non-JSON results ignored
@@ -413,6 +477,35 @@ export const turnLoop = async (
           contentForModel = result;
         }
 
+        // Keep doc list progress updated when we fetch DOM
+        if (!errorMessage && resourceGuardCfg.enabled) {
+          const prog = ensureDocProgress(agentMemory, resourceGuardCfg);
+          if (prog) {
+            if (fnName === 'get_dom') {
+              const { items, scriptDocs } = parseDocListFromDom(result);
+              if (items.length) {
+                prog.items = items;
+                prog.lastScriptCount = scriptDocs || items.length;
+                prog.lastSummary = `docs:${items.length}`;
+                step.events.push(`📊 Detected document list (${items.length} items)`);
+              }
+            } else if (fnName === 'list_local_files') {
+              try {
+                const parsed = JSON.parse(result);
+                const files = parsed?.files || [];
+                if (Array.isArray(files) && files.length) {
+                  prog.items = files.map(f => ({ id: f, title: f, href: f }));
+                  prog.lastScriptCount = files.length;
+                  prog.lastSummary = `files:${files.length}`;
+                  step.events.push(`📊 Detected local files (${files.length} items)`);
+                }
+              } catch {
+                // ignore parse errors
+              }
+            }
+          }
+        }
+
         toolResponses.push({
           role: 'tool',
           tool_call_id: call.id,
@@ -465,6 +558,24 @@ export const turnLoop = async (
     // ─────────────────────────────────────────────
     const finalResponse = finalResponseHandler(msg);
     if (finalResponse !== null) {
+      const prog = ensureDocProgress(agentMemory, resourceGuardCfg);
+      if (prog?.items.length && prog.downloaded.size < prog.items.length) {
+        const remaining = prog.items
+          .filter(i => !prog.downloaded.has(i.id))
+          .map(i => i.title || i.id)
+          .slice(0, 10);
+        const remainText = remaining.length ? remaining.join('; ') : 'unknown items';
+        const guardMsg = `Auto-guard: downloaded ${prog.downloaded.size}/${prog.items.length}. Remaining: ${remainText}`;
+        console.log(`[guard] ${guardMsg}`);
+        step.events.push(guardMsg);
+        step.result = '🟡 In Progress';
+        recordStep(step);
+        // Nudge model to continue
+        messages.push({ role: 'assistant', content: guardMsg });
+        // Continue loop without exiting
+        turnRetries = 0;
+        continue;
+      }
       step.events.push(finalResponse.finalMessage);
       step.result = finalResponse.success ? '✅ Mission Success' : '❌ Mission Failure';
       recordStep(step);
@@ -488,3 +599,10 @@ export const turnLoop = async (
 
   return { success: false, steps: stepsArchive };
 };
+
+// Expose small helper bundle for unit tests (no production use).
+export const __docProgressInternals = {
+  ensureDocProgress,
+  parseDocListFromDom,
+  extractDocIdFromUrl,
+};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "testronaut",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "main": "./runner/testronaut.js",
   "bin": {
-    "testronaut": "./bin/cli.js"
+    "testronaut": "bin/cli.js"
   },
   "exports": {
     ".": "./runner/testronaut.js",
@@ -24,6 +24,7 @@
     "@google/generative-ai": "^0.24.1",
     "cheerio": "^1.1.0",
     "dotenv": "^17.2.0",
+    "fast-glob": "^3.3.3",
     "inquirer": "^12.9.1",
     "node-fetch": "^3.3.2",
     "openai": "^5.10.2",

package/runner/testronaut.js

@@ -23,9 +23,20 @@
  */
 
 
+import fs from 'fs';
+import path from 'path';
 import { runAgent } from '../core/agent.js';
 import { redactPasswordInText } from '../core/redaction.js';
-import { loadConfig, enforceTurnBudget, getRetryLimit } from '../core/config.js';
+import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getResourceGuardConfig } from '../core/config.js';
+
+// Check process env for debug toggles (shared helper for tests and CLI).
+const isDebugEnabled = () => {
+  const raw = String(process.env.TESTRONAUT_DEBUG || '').trim().toLowerCase();
+  return ['1', 'true', 'yes', 'on'].includes(raw);
+};
+
+// Presentable string for DOM list limit logging/debug output.
+const formatListLimit = (v) => v === Infinity ? 'all' : v;
 
 /**
  * Run a mission flow.
@@ -40,12 +51,56 @@ export async function runMissions({ preMission, mission, postMission }, missionN
   const maxTurns = effectiveMax;
   const retryInfo = getRetryLimit(cfg);
   const retryLimit = retryInfo.value;
+  const domListLimitInfo = getDomListLimit(cfg);
+  const resourceGuard = getResourceGuardConfig(cfg);
+  const debugEnabled = isDebugEnabled();
   if (notes.length) {
     console.warn(notes.join('\n'));
   }
   if (retryInfo.clamped) {
     console.warn(`⚠️ Retry limit clamped to ${retryLimit} (allowed range 1-10).`);
   }
+  if (domListLimitInfo?.clamped) {
+    console.warn(`⚠️ DOM list limit clamped to ${domListLimitInfo.value} (allowed 0-100 or "all"/"none").`);
+  }
+  if (domListLimitInfo?.mode === 'all') {
+    console.warn('⚠️ DOM list limit is set to "all". This can dramatically increase token usage and may break flows on heavy pages.');
+  }
+  if (debugEnabled) {
+    const cfgDomRaw = cfg?.dom?.listItemLimit ?? cfg?.dom?.listLimit ?? cfg?.domListLimit;
+    console.log('[debug] Debug mode enabled');
+    console.log('[debug] Turn limits', {
+      maxTurns,
+      softMax: limits.softMaxTurns,
+      hardMax: limits.hardMaxTurns,
+      hardMin: limits.hardMinTurns,
+    });
+    console.log('[debug] Retry limit', { retryLimit, source: retryInfo.source, clamped: retryInfo.clamped });
+    console.log('[debug] DOM list limit', {
+      env: process.env.TESTRONAUT_DOM_LIST_LIMIT ?? 'unset',
+      config: cfgDomRaw ?? 'unset',
+      resolved: formatListLimit(domListLimitInfo?.value),
+      mode: domListLimitInfo?.mode,
+      source: domListLimitInfo?.source,
+      clamped: domListLimitInfo?.clamped,
+    });
+    console.log('[debug] Resource guard', {
+      enabled: resourceGuard.enabled,
+      hrefIncludes: resourceGuard.hrefIncludes,
+      dataTypes: resourceGuard.dataTypes,
+    });
+    // Helpful for upload missions: show missions/files contents
+    const filesDir = path.resolve(process.cwd(), 'missions/files');
+    try {
+      const entries = fs.readdirSync(filesDir);
+      const pdfs = entries.filter(f => f.toLowerCase().endsWith('.pdf'));
+      console.log(`[debug] missions/files dir: ${filesDir}`);
+      console.log(`[debug] missions/files entries (${entries.length}):`, entries);
+      if (pdfs.length) console.log(`[debug] missions/files PDFs (${pdfs.length}):`, pdfs);
+    } catch (err) {
+      console.log(`[debug] missions/files not readable: ${err.message}`);
+    }
+  }
 
   // 2) Normalize submissions
   const normalizeToArray = (x) => (Array.isArray(x) ? x : x ? [x] : []);
@@ -128,7 +183,13 @@ export async function runMissions({ preMission, mission, postMission }, missionN
   );
 
   // 3) Execute
-  const success = await runAgent(goals, missionName, maxTurns, retryLimit);
+  const success = await runAgent(
+    goals,
+    missionName,
+    maxTurns,
+    retryLimit,
+    { domListLimit: domListLimitInfo?.value, debug: debugEnabled, resourceGuard }
+  );
   if (!success) {
     console.log(`❌ Aborting after failed goal.`);
     return;
@@ -141,3 +202,6 @@ export async function runMissions({ preMission, mission, postMission }, missionN
   console.log('\n✅ Mission flow complete.');
   return success;
 }
+
+// Exposed for unit tests.
+export const __test__ = { isDebugEnabled, formatListLimit };

package/tests/binTests/cli.helpers.test.js

@@ -33,4 +33,13 @@ describe('cli helpers', () => {
     expect(latest?.htmlFile).toBe('run_200.html');
     expect(latest?.jsonFile).toBe('run_200.json');
   });
+
+  it('parses booleans in a tolerant way', () => {
+    const { parseBool } = __test__;
+    expect(parseBool('true')).toBe(true);
+    expect(parseBool('0')).toBe(false);
+    expect(parseBool('off')).toBe(false);
+    expect(parseBool('')).toBeNull();
+    expect(parseBool('maybe')).toBeNull();
+  });
 });

package/tests/binTests/init.test.js

@@ -77,6 +77,8 @@ describe('initializeTestronautProject', () => {
     expect(cfg.initialized).toBe(true);
     expect(cfg.outputDir).toBe('missions/mission_reports');
     expect(typeof cfg.maxTurns).toBe('number');
+    expect(cfg.dom?.listItemLimit).toBe(3);
+    expect(cfg.resourceGuard?.enabled).toBe(true);
 
     // .env
     const envPath = path.join(temp, '.env');
@@ -108,6 +110,8 @@ describe('initializeTestronautProject', () => {
     const cfg = readJson(path.join(temp, 'testronaut-config.json'));
     expect(cfg.provider).toBe('gemini');
     expect(cfg.model).toBe('gemini-2.5-flash');
+    expect(cfg.dom?.listItemLimit).toBe(3);
+    expect(cfg.resourceGuard?.enabled).toBe(true);
 
     const envTxt = fs.readFileSync(path.join(temp, '.env'), 'utf8');
     expect(envTxt).toMatch(/GEMINI_API_KEY=AIza/);
@@ -185,5 +189,7 @@ describe('initializeTestronautProject', () => {
     expect(cfg.projectName).toBe('my-project'); // preserved
     expect(cfg.outputDir).toBe('missions/mission_reports'); // default filled in
     expect(cfg.maxTurns).toBe(20); // default filled in
+    expect(cfg.dom?.listItemLimit).toBe(3);
+    expect(cfg.resourceGuard?.enabled).toBe(true);
   });
 });

package/tests/binTests/initHelpersTests/defaultConfig.test.js

@@ -8,5 +8,8 @@ describe('defaultConfig', () => {
     expect(cfg.outputDir).toBe('missions/mission_reports');
     expect(cfg.projectName).toBe('my-app');
     expect(cfg.maxTurns).toBe(20);
+    expect(cfg.dom?.listItemLimit).toBe(3);
+    expect(cfg.resourceGuard?.enabled).toBe(true);
+    expect(cfg.resourceGuard?.hrefIncludes).toContain('/document/');
   });
 });