testronaut 1.3.1 → 1.3.3

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,43 @@ 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();
+  });
+
+  it('parses vercel bypass flags and removes them from args', () => {
+    const { parseVercelBypassArgs } = __test__;
+    const res = parseVercelBypassArgs(['--dev', '--vercel-bypass=secret123', 'login']);
+    expect(res.secret).toBe('secret123');
+    expect(res.args).toEqual(['--dev', 'login']);
+    expect(res.invalid).toBe(false);
+  });
+
+  it('parses vercel bypass value from next arg', () => {
+    const { parseVercelBypassArgs } = __test__;
+    const res = parseVercelBypassArgs(['--vercel_bypass', 'abc', 'login']);
+    expect(res.secret).toBe('abc');
+    expect(res.args).toEqual(['login']);
+    expect(res.invalid).toBe(false);
+  });
+
+  it('handles missing vercel bypass value', () => {
+    const { parseVercelBypassArgs } = __test__;
+    const res = parseVercelBypassArgs(['--vercel-bypass']);
+    expect(res.secret).toBeUndefined();
+    expect(res.args).toEqual([]);
+    expect(res.invalid).toBe(true);
+  });
+
+  it('builds the vercel bypass header when provided', () => {
+    const { createVercelBypassHeader } = __test__;
+    expect(createVercelBypassHeader('abc')).toEqual({ 'x-vercel-protection-bypass': 'abc' });
+    expect(createVercelBypassHeader('')).toEqual({});
+  });
 });

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

@@ -11,6 +11,8 @@ import {
   getRetryLimit,
   resolveTurnLimits,
   enforceTurnBudget,
+  getDomListLimit,
+  getResourceGuardConfig,
 } from '../../core/config.js';
 
 describe('core/config', () => {
@@ -105,6 +107,100 @@ describe('core/config', () => {
     });
   });
 
+  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 };

package/tests/coreTests/missionDiscovery.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { discoverMissionFiles } from '../../core/missionDiscovery.js';
+
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-missions-'));
+}
+
+function writeJson(p, obj) {
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2));
+}
+
+const temps = [];
+
+afterEach(() => {
+  while (temps.length) {
+    const dir = temps.pop();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('discoverMissionFiles', () => {
+  it('falls back to legacy discovery when missions block is missing', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    const missionsDir = path.join(tmp, 'missions');
+    fs.mkdirSync(missionsDir, { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'alpha.mission.js'), '// ok');
+    fs.writeFileSync(path.join(missionsDir, 'beta.txt'), '// ignore');
+    fs.mkdirSync(path.join(missionsDir, 'nested'), { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'nested', 'gamma.mission.js'), '// nested');
+    fs.writeFileSync(path.join(missionsDir, 'delta.mission.ts'), '// ts not included by default');
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.root).toBe(path.resolve(tmp, 'missions'));
+    expect(res.files).toEqual(['alpha.mission.js']);
+  });
+
+  it('respects missions.root with include patterns', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    const missionsDir = path.join(tmp, 'custom');
+    fs.mkdirSync(path.join(missionsDir, 'nested'), { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'root.mission.js'), '// root');
+    fs.writeFileSync(path.join(missionsDir, 'nested', 'deep.mission.ts'), '// nested ts');
+
+    writeJson(path.join(tmp, 'testronaut-config.json'), {
+      missions: {
+        root: './custom',
+        include: ['*.mission.js', 'nested/**/*.mission.ts'],
+      },
+    });
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.root).toBe(path.resolve(tmp, 'custom'));
+    expect(res.files).toEqual(['nested/deep.mission.ts', 'root.mission.js']);
+  });
+
+  it('applies missions.exclude after includes', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    const missionsDir = path.join(tmp, 'custom');
+    fs.mkdirSync(path.join(missionsDir, 'ignore'), { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'keep.mission.js'), '// keep');
+    fs.writeFileSync(path.join(missionsDir, 'ignore', 'skip.mission.js'), '// skip');
+    fs.writeFileSync(path.join(missionsDir, 'keep.wip.mission.js'), '// skip by pattern');
+
+    writeJson(path.join(tmp, 'testronaut-config.json'), {
+      missions: {
+        root: './custom',
+        include: ['**/*.mission.js'],
+        exclude: ['ignore/**', '**/*.wip.mission.js'],
+      },
+    });
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.files).toEqual(['keep.mission.js']);
+  });
+});

package/tests/coreTests/turnLoop.test.js

@@ -22,6 +22,7 @@ const { shared } = vi.hoisted(() => {
             mode: 'save',
           })
         ),
+        list_local_files: vi.fn(async () => JSON.stringify({ files: ['a.pdf', 'b.pdf'] })),
       },
     },
   };
@@ -63,6 +64,7 @@ vi.mock('../../tools/toolSchema.js', () => ({
     { type: 'function', function: { name: 'click_text', description: 'click by text', parameters: {} } },
     { type: 'function', function: { name: 'get_dom', description: 'get DOM html', parameters: {} } },
     { type: 'function', function: { name: 'screenshot', description: 'take a screenshot', parameters: {} } },
+    { type: 'function', function: { name: 'list_local_files', description: 'list files', parameters: {} } },
   ],
 }));
 
@@ -96,7 +98,7 @@ vi.mock('../../core/redaction.js', () => ({
 }));
 
 // Import SUT after mocks
-import { turnLoop } from '../../core/turnLoop.js';
+import { turnLoop, __docProgressInternals } from '../../core/turnLoop.js';
 
 // Helper
 function baseMessages() {
@@ -226,4 +228,47 @@ describe('turnLoop', () => {
     expect(res.steps[1].result).toBe('✅ Passed');
     expect(res.steps[2].result).toMatch(/Success/);
   });
+
+  describe('__docProgressInternals helpers', () => {
+    const { parseDocListFromDom, extractDocIdFromUrl, ensureDocProgress } = __docProgressInternals;
+
+    it('parses injected doc list summary', () => {
+      const html = `<pre data-testronaut-doc-list>
+List
+- [123] File A /document/123
+- [456] File B /document/456
+</pre>`;
+      const { items, scriptDocs } = parseDocListFromDom(html);
+      expect(items).toHaveLength(2);
+      expect(items[0].id).toBe('123');
+      expect(items[1].title.length).toBeGreaterThan(0);
+      expect(scriptDocs).toBe(2);
+    });
+
+    it('extracts doc id from url and tracks progress', () => {
+      expect(extractDocIdFromUrl('https://x.com/document/999/foo')).toBe('999');
+      expect(extractDocIdFromUrl('nope')).toBe('');
+
+      const mem = {};
+      const cfg = { enabled: true, hrefIncludes: ['/doc'], dataTypes: ['doc'] };
+      const prog = ensureDocProgress(mem, cfg);
+      expect(prog.patterns).toBe(cfg);
+      prog.items = [{ id: '1', title: 'Doc 1' }];
+      prog.downloaded.add('1');
+      expect(prog.downloaded.has('1')).toBe(true);
+    });
+
+    it('updates progress from list_local_files results', () => {
+      const mem = {};
+      const cfg = { enabled: true, hrefIncludes: ['/doc'], dataTypes: ['doc'] };
+      const prog = ensureDocProgress(mem, cfg);
+      prog.items = [];
+      // simulate list_local_files JSON result
+      const parsed = JSON.parse(JSON.stringify({ files: ['x.pdf', 'y.pdf'] }));
+      prog.items = parsed.files.map(f => ({ id: f, title: f, href: f }));
+      prog.downloaded.add('x.pdf');
+      expect(prog.items).toHaveLength(2);
+      expect(prog.downloaded.has('x.pdf')).toBe(true);
+    });
+  });
 });

package/tests/runnerTests/testronaut.test.js

@@ -10,19 +10,25 @@ vi.mock('../../core/config.js', () => ({
   loadConfig: vi.fn(),
   enforceTurnBudget: vi.fn(),
   getRetryLimit: vi.fn(),
+  getDomListLimit: vi.fn(),
+  getResourceGuardConfig: vi.fn(),
 }));
 
 import { runAgent } from '../../core/agent.js';
-import { loadConfig, enforceTurnBudget, getRetryLimit } from '../../core/config.js';
+import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getResourceGuardConfig } from '../../core/config.js';
 
 // Adjust the import path if your file lives elsewhere
-import { runMissions } from '../../runner/testronaut.js';
+import { runMissions, __test__ as testronautInternals } from '../../runner/testronaut.js';
 
 describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
+  const OLD_ENV = { ...process.env };
   beforeEach(() => {
+    process.env = { ...OLD_ENV };
     vi.clearAllMocks();
     // Default retry limit unless overridden in a test
     getRetryLimit.mockReturnValue({ value: 2, source: 'default', clamped: false });
+    getDomListLimit.mockReturnValue({ value: 3, mode: 'number', source: 'default', clamped: false });
+    getResourceGuardConfig.mockReturnValue({ enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] });
   });
 
   it('passes effectiveMax to runAgent and logs any notes', async () => {
@@ -50,7 +56,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
       expect.stringContaining('Clamping to 200')
     );
     expect(runAgent).toHaveBeenCalledWith(
-      expect.any(Array), 'Budgeted Run', 200, 2
+      expect.any(Array), 'Budgeted Run', 200, 2, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } }
     );
 
     warn.mockRestore();
@@ -77,7 +83,33 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
     await runMissions({ mission: 'No warnings' }, 'Clean');
 
     expect(warn).not.toHaveBeenCalled();
-    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Clean', 20, 3);
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Clean', 20, 3, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } });
+
+    warn.mockRestore();
+    log.mockRestore();
+  });
+
+  it('warns when the DOM list limit is clamped', async () => {
+    loadConfig.mockResolvedValue({});
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 20,
+      limits: {},
+      notes: [],
+      strict: false,
+    });
+    getDomListLimit.mockReturnValue({ value: 100, mode: 'number', source: 'config', clamped: true });
+
+    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: 'Clamp lists' }, 'Clamp Mission');
+
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('DOM list limit clamped to 100')
+    );
 
     warn.mockRestore();
     log.mockRestore();
@@ -144,7 +176,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
     expect(goals[1].submissionName).toMatch(/^My Mission/);
 
     // Effective max turns and retry limit passed through
-    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15, 2);
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15, 2, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } });
 
     log.mockRestore();
   });
@@ -166,4 +198,37 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
 
     log.mockRestore();
   });
+
+  it('passes debug flag through when TESTRONAUT_DEBUG is set', async () => {
+    process.env.TESTRONAUT_DEBUG = 'true';
+    loadConfig.mockResolvedValue({});
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 20,
+      limits: {},
+      notes: [],
+      strict: false,
+    });
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    runAgent.mockResolvedValue([
+      { steps: [{ result: 'SUCCESS: ok' }], status: 'passed' },
+    ]);
+
+    await runMissions({ mission: 'Debug' }, 'Debug Mission');
+
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Debug Mission', 20, 2, { domListLimit: 3, debug: true, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } });
+
+    log.mockRestore();
+  });
+
+  describe('__test__ helpers', () => {
+    it('formats list limits and reads debug env', () => {
+      const { isDebugEnabled, formatListLimit } = testronautInternals;
+      process.env.TESTRONAUT_DEBUG = 'on';
+      expect(isDebugEnabled()).toBe(true);
+      process.env.TESTRONAUT_DEBUG = '0';
+      expect(isDebugEnabled()).toBe(false);
+      expect(formatListLimit(Infinity)).toBe('all');
+      expect(formatListLimit(5)).toBe(5);
+    });
+  });
 });

package/tests/toolsTests/domControl.test.js

@@ -195,6 +195,41 @@ describe('domControl helpers', () => {
       // Total children: 2 cards + 1 other + 1 marker
       expect(rootChildren.length).toBe(4);
     });
+
+    it('keeps all repeated divs when maxAllowed is Infinity', () => {
+      const html = `
+        <div id="root">
+          <div class="card">1</div>
+          <div class="card">2</div>
+          <div class="card">3</div>
+          <div class="card">4</div>
+        </div>
+      `;
+      const $ = cheerio.load(html);
+
+      reduceRepeatedDivs($, Infinity);
+
+      const cardDivs = $('#root').children('div.card');
+      expect(cardDivs.length).toBe(4);
+      expect($('#root').children('div[data-collapsed="true"]').length).toBe(0);
+    });
+
+    it('removes all repeated divs when maxAllowed is 0', () => {
+      const html = `
+        <div id="root">
+          <div class="card">A</div>
+          <div class="card">B</div>
+        </div>
+      `;
+      const $ = cheerio.load(html);
+
+      reduceRepeatedDivs($, 0);
+
+      const cardDivs = $('#root').children('div.card');
+      expect(cardDivs.length).toBe(0);
+      const markers = $('#root').children('div[data-collapsed="true"]');
+      expect(markers.length).toBe(1);
+    });
   });
 
   describe('removeObfuscatedClassNames', () => {

package/tests/toolsTests/toolSchema.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import toolsSchema from '../../tools/toolSchema.js';
+
+describe('tools/toolSchema', () => {
+  it('includes resource_progress tool with empty params', () => {
+    const entry = toolsSchema.find(t => t.function?.name === 'resource_progress');
+    expect(entry?.type).toBe('function');
+    expect(entry.function.parameters).toEqual({ type: 'object', properties: {} });
+    expect(entry.function.description).toMatch(/remaining/i);
+  });
+
+  it('includes list_local_files tool', () => {
+    const entry = toolsSchema.find(t => t.function?.name === 'list_local_files');
+    expect(entry?.type).toBe('function');
+    expect(entry.function.parameters?.properties).toHaveProperty('dir');
+  });
+
+  it('defines navigate and download_file with required fields', () => {
+    const nav = toolsSchema.find(t => t.function?.name === 'navigate');
+    const download = toolsSchema.find(t => t.function?.name === 'download_file');
+    expect(nav?.function?.parameters?.required).toContain('url');
+    expect(download?.function?.parameters?.properties).toHaveProperty('url');
+  });
+});