testronaut 1.3.0 → 1.3.2

package/core/turnLoop.js

@@ -63,10 +63,56 @@ 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 = [];
 let shouldBackoff;
+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
@@ -171,16 +217,31 @@ export const turnLoop = async (
   currentStep = {},
   ctx = {} // { steps, missionName, groundControl }
 ) => {
-  const { steps = [], missionName, groundControl = createEmptyGroundControl() } = ctx;
+  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;
   
   // 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 {}
   };
   
@@ -190,7 +251,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)
@@ -211,7 +284,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
@@ -231,7 +304,7 @@ 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.
@@ -273,7 +346,7 @@ export const turnLoop = async (
           step.events.push('❌ Too many retries. Exiting.');
           step.result = '❌ Failure';
           recordStep(step);
-          return steps;
+          return { success: false, steps: stepsArchive };
         }
         retryCount += 1;
         turn -= 1;
@@ -283,7 +356,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;
       }
@@ -319,6 +392,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;
@@ -335,6 +409,7 @@ export const turnLoop = async (
         } catch (e) {
           errorMessage = `ERROR: ${e.message}`;
           result = errorMessage;
+          hadToolIssues = true;
         }
 
         // Capture and log any file upload/download events (for reports)
@@ -348,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
@@ -388,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,
@@ -416,7 +534,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;
     }
@@ -426,10 +558,29 @@ 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);
-      return { success: finalResponse.finalMessage, steps };
+      turnRetries = 0;
+      return { success: finalResponse.success, finalMessage: finalResponse.finalMessage, steps: stepsArchive };
     }
 
     // ─────────────────────────────────────────────
@@ -443,5 +594,15 @@ 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 };
+};
+
+// 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.0",
+  "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 } 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.
@@ -38,9 +49,58 @@ export async function runMissions({ preMission, mission, postMission }, missionN
   const cfg = await loadConfig();
   const { effectiveMax, limits, notes } = enforceTurnBudget(cfg);
   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] : []);
@@ -123,7 +183,13 @@ export async function runMissions({ preMission, mission, postMission }, missionN
   );
 
   // 3) Execute
-  const success = await runAgent(goals, missionName, maxTurns);
+  const success = await runAgent(
+    goals,
+    missionName,
+    maxTurns,
+    retryLimit,
+    { domListLimit: domListLimitInfo?.value, debug: debugEnabled, resourceGuard }
+  );
   if (!success) {
     console.log(`❌ Aborting after failed goal.`);
     return;
@@ -136,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

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import fs from 'fs';
+
+// Import helper exports from cli.js
+import { __test__ } from '../../bin/cli.js';
+
+describe('cli helpers', () => {
+  it('guessMimeType returns expected types', () => {
+    const { guessMimeType } = __test__;
+    expect(guessMimeType('file.html')).toContain('text/html');
+    expect(guessMimeType('file.json')).toContain('application/json');
+    expect(guessMimeType('file.unknown')).toBe('application/octet-stream');
+  });
+
+  it('safeJoin prevents traversal', () => {
+    const { safeJoin } = __test__;
+    const root = '/tmp/root';
+    expect(safeJoin(root, '/sub/ok.txt')).toBe(path.resolve('/tmp/root/sub/ok.txt'));
+    expect(safeJoin(root, '/../etc/passwd')).toBeNull();
+  });
+
+  it('findLatestReportPair finds latest html/json', () => {
+    const { findLatestReportPair } = __test__;
+    const tmp = fs.mkdtempSync(path.join(process.cwd(), 'testronaut-report-'));
+    const r1 = path.join(tmp, 'run_100.html');
+    const r2 = path.join(tmp, 'run_200.html');
+    fs.writeFileSync(r1, 'a');
+    fs.writeFileSync(r2, 'b');
+    fs.writeFileSync(path.join(tmp, 'run_200.json'), '{}');
+
+    const latest = findLatestReportPair(tmp);
+    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/');
   });
 });

package/tests/coreTests/config.test.js

@@ -8,8 +8,11 @@ import { readFile } from 'node:fs/promises';
 import {
   loadConfig,
   getMaxTurns,
+  getRetryLimit,
   resolveTurnLimits,
   enforceTurnBudget,
+  getDomListLimit,
+  getResourceGuardConfig,
 } from '../../core/config.js';
 
 describe('core/config', () => {
@@ -64,6 +67,140 @@ describe('core/config', () => {
     });
   });
 
+  describe('getRetryLimit', () => {
+    const OLD_ENV = { ...process.env };
+    beforeEach(() => {
+      process.env = { ...OLD_ENV };
+      delete process.env.TESTRONAUT_RETRY_LIMIT;
+    });
+    afterEach(() => {
+      process.env = { ...OLD_ENV };
+    });
+
+    it('returns default when missing', () => {
+      const res = getRetryLimit({});
+      expect(res.value).toBe(2);
+      expect(res.source).toBe('default');
+      expect(res.clamped).toBe(false);
+    });
+
+    it('uses config value and clamps to range', () => {
+      expect(getRetryLimit({ retryLimit: 5 }).value).toBe(5);
+      const high = getRetryLimit({ retryLimit: 99 });
+      expect(high.value).toBe(10);
+      expect(high.clamped).toBe(true);
+      const low = getRetryLimit({ retryLimit: 0 });
+      expect(low.value).toBe(1);
+      expect(low.clamped).toBe(true);
+    });
+
+    it('prefers env over config and clamps', () => {
+      process.env.TESTRONAUT_RETRY_LIMIT = '8';
+      const res = getRetryLimit({ retryLimit: 3 });
+      expect(res.value).toBe(8);
+      expect(res.source).toBe('env');
+
+      process.env.TESTRONAUT_RETRY_LIMIT = '0';
+      const clampedLow = getRetryLimit({ retryLimit: 3 });
+      expect(clampedLow.value).toBe(1);
+      expect(clampedLow.clamped).toBe(true);
+    });
+  });
+
+  describe('getDomListLimit', () => {
+    const OLD_ENV = { ...process.env };
+    beforeEach(() => {
+      process.env = { ...OLD_ENV };
+      delete process.env.TESTRONAUT_DOM_LIST_LIMIT;
+    });
+    afterEach(() => {
+      process.env = { ...OLD_ENV };
+    });
+
+    it('returns default when missing', () => {
+      const res = getDomListLimit({});
+      expect(res.value).toBe(3);
+      expect(res.mode).toBe('number');
+      expect(res.source).toBe('default');
+      expect(res.clamped).toBe(false);
+    });
+
+    it('uses config value (nested) and clamps to range', () => {
+      const res = getDomListLimit({ dom: { listItemLimit: 250 } });
+      expect(res.value).toBe(100);
+      expect(res.mode).toBe('number');
+      expect(res.source).toBe('config');
+      expect(res.clamped).toBe(true);
+
+      const nestedAlt = getDomListLimit({ dom: { listLimit: '9' } });
+      expect(nestedAlt.value).toBe(9);
+      expect(nestedAlt.source).toBe('config');
+    });
+
+    it('prefers env override and accepts keywords', () => {
+      process.env.TESTRONAUT_DOM_LIST_LIMIT = 'all';
+      const allRes = getDomListLimit({ domListLimit: 2 });
+      expect(allRes.value).toBe(Infinity);
+      expect(allRes.mode).toBe('all');
+      expect(allRes.source).toBe('env');
+
+      process.env.TESTRONAUT_DOM_LIST_LIMIT = 'none';
+      const noneRes = getDomListLimit({ domListLimit: 5 });
+      expect(noneRes.value).toBe(0);
+      expect(noneRes.mode).toBe('none');
+      expect(noneRes.source).toBe('env');
+    });
+
+    it('accepts numeric strings', () => {
+      const res = getDomListLimit({ domListLimit: '7' });
+      expect(res.value).toBe(7);
+      expect(res.mode).toBe('number');
+    });
+  });
+
+  describe('getResourceGuardConfig', () => {
+    const OLD_ENV = { ...process.env };
+    beforeEach(() => {
+      process.env = { ...OLD_ENV };
+      delete process.env.TESTRONAUT_RESOURCE_GUARD;
+      delete process.env.TESTRONAUT_RESOURCE_HREF_PATTERNS;
+      delete process.env.TESTRONAUT_RESOURCE_DATA_TYPES;
+    });
+    afterEach(() => {
+      process.env = { ...OLD_ENV };
+    });
+
+    it('returns defaults when nothing is set', () => {
+      const res = getResourceGuardConfig({});
+      expect(res.enabled).toBe(true);
+      expect(res.hrefIncludes.length).toBeGreaterThan(0);
+      expect(res.dataTypes).toContain('document');
+    });
+
+    it('respects env toggles and lists', () => {
+      process.env.TESTRONAUT_RESOURCE_GUARD = 'false';
+      process.env.TESTRONAUT_RESOURCE_HREF_PATTERNS = '/a,/b';
+      process.env.TESTRONAUT_RESOURCE_DATA_TYPES = 'doc,file';
+      const res = getResourceGuardConfig({ resourceGuard: { enabled: true } });
+      expect(res.enabled).toBe(false);
+      expect(res.hrefIncludes).toEqual(['/a', '/b']);
+      expect(res.dataTypes).toEqual(['doc', 'file']);
+    });
+
+    it('falls back to config arrays when env missing', () => {
+      const res = getResourceGuardConfig({
+        resourceGuard: {
+          enabled: 'yes',
+          hrefIncludes: ['/x', '/y'],
+          dataTypes: ['row'],
+        },
+      });
+      expect(res.enabled).toBe(true);
+      expect(res.hrefIncludes).toEqual(['/x', '/y']);
+      expect(res.dataTypes).toEqual(['row']);
+    });
+  });
+
   describe('enforceTurnBudget (lenient)', () => {
     it('clamps > hardMaxTurns', () => {
       const cfg = { maxTurns: 1000 };