testronaut 1.9.3 → 1.10.0

package/llm/gemini/geminiProvider.js

@@ -28,6 +28,13 @@
 
 import { GoogleGenerativeAI } from '@google/generative-ai';
 
+// Gemini 3 validates thought signatures on function calls in the current turn.
+// Calls synthesized by Testronaut (for example, automatic get_dom calls) were
+// not emitted by Gemini and therefore have no real signature to preserve.
+// Google documents this sentinel specifically for deterministic client-injected
+// function-call history.
+const SYNTHETIC_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+
 /**
  * Convert OpenAI-like messages → Gemini "contents" array.
  * - System messages are coalesced and injected as a prefix into the next user turn.
@@ -49,29 +56,41 @@ function toGeminiContents(messages) {
       continue;
     }
 
+    // Gemini 3 requires thought signatures to be returned exactly where the
+    // model emitted them. Prefer the untouched provider parts when available.
+    const geminiParts = m.provider_metadata?.gemini?.parts;
+    if (m.role === 'assistant' && Array.isArray(geminiParts) && geminiParts.length) {
+      contents.push({ role: 'model', parts: geminiParts });
+      continue;
+    }
+
     // Assistant tool calls → Gemini functionCall parts on a model turn
     if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
       contents.push({
         role: 'model',
-        parts: m.tool_calls.map(tc => ({
+        parts: m.tool_calls.map((tc, index) => ({
           functionCall: {
             name: tc.function?.name,
             args: safeJsonParse(tc.function?.arguments) ?? {},
           },
+          // For parallel calls Gemini expects the signature only on the first
+          // functionCall part. Genuine provider parts take the branch above and
+          // retain their original signatures instead of receiving this sentinel.
+          ...(index === 0 ? { thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE } : {}),
         })),
       });
       continue;
     }
 
-    // Tool results → encode as a user turn with a JSON part the model can parse
+    // Tool results → Gemini function responses. This keeps function-calling
+    // history valid for Gemini 3 and gives earlier models structured results.
     if (m.role === 'tool') {
+      const parsed = safeJsonParse(m.content);
       const parts = [{
-        text: JSON.stringify({
-          _tool_result: true,
-          tool_call_id: m.tool_call_id,
+        functionResponse: {
           name: m.name,
-          content: m.content,
-        }),
+          response: parsed ?? { result: m.content },
+        },
       }];
       contents.push({ role: 'user', parts });
       continue;
@@ -148,7 +167,14 @@ function fromGeminiCandidate(cand) {
   }
 
   const content = texts.join('');
-  return { role: 'assistant', content, tool_calls: tool_calls.length ? tool_calls : undefined };
+  return {
+    role: 'assistant',
+    content,
+    tool_calls: tool_calls.length ? tool_calls : undefined,
+    // Retain all parts, including Gemini 3 thought signatures and function IDs,
+    // so the next request can replay them without lossy format conversion.
+    provider_metadata: { gemini: { parts } },
+  };
 }
 
 function cryptoRandomId() {
@@ -193,6 +219,8 @@ export class GeminiProvider {
     const usageMeta = res?.response?.usageMetadata;
     const usage = {
       total_tokens: usageMeta?.totalTokenCount,
+      input_tokens: usageMeta?.promptTokenCount,
+      output_tokens: usageMeta?.candidatesTokenCount,
       providerRaw: usageMeta,
     };
 

package/llm/openAI/openaiProvider.js

@@ -63,6 +63,8 @@ export class OpenAIProvider {
     const message = res.choices?.[0]?.message ?? { role: 'assistant', content: '' };
     const usage = {
       total_tokens: res.usage?.total_tokens,
+      input_tokens: res.usage?.prompt_tokens,
+      output_tokens: res.usage?.completion_tokens,
       providerRaw: res.usage,
     };
 

package/package.json

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

package/runner/testronaut.js

@@ -29,8 +29,11 @@ import 'dotenv/config';
 import fs from 'fs';
 import path from 'path';
 import { redactPasswordInText } from '../core/redaction.js';
-import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getResourceGuardConfig, getHumanInputConfig } from '../core/config.js';
+import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getAutomaticDomLimit, getResourceGuardConfig, getHumanInputConfig } from '../core/config.js';
 import { normalizeTags } from '../core/tags.js';
+import { launchProtocol, unwrapLaunchProtocol } from '../core/launchProtocol.js';
+
+export { launchProtocol };
 
 // Check process env for debug toggles (shared helper for tests and CLI).
 const isDebugEnabled = () => {
@@ -55,6 +58,7 @@ export async function runMissions({ preMission, mission, postMission, tags = []
   const retryInfo = getRetryLimit(cfg);
   const retryLimit = retryInfo.value;
   const domListLimitInfo = getDomListLimit(cfg);
+  const automaticDomLimitInfo = getAutomaticDomLimit(cfg);
   const resourceGuard = getResourceGuardConfig(cfg);
   const humanInput = getHumanInputConfig(cfg);
   const debugEnabled = isDebugEnabled();
@@ -99,6 +103,7 @@ export async function runMissions({ preMission, mission, postMission, tags = []
       source: domListLimitInfo?.source,
       clamped: domListLimitInfo?.clamped,
     });
+    console.log('[debug] Automatic DOM limit', automaticDomLimitInfo);
     console.log('[debug] Resource guard', {
       enabled: resourceGuard.enabled,
       hrefIncludes: resourceGuard.hrefIncludes,
@@ -161,12 +166,16 @@ export async function runMissions({ preMission, mission, postMission, tags = []
 
   if (pre.length) {
     goals.push(
-      ...pre.map((fn, i) => ({
-        goal: fn,
-        label: 'pre-mission',          // legacy label (kept for logs)
-        submissionType: 'premission',  // normalized
-        submissionName: pickName('premission', fn, i),
-      }))
+      ...pre.map((fn, i) => {
+        const { goal, protocol } = unwrapLaunchProtocol(fn);
+        return {
+          goal,
+          launchProtocol: protocol,
+          label: 'pre-mission',          // legacy label (kept for logs)
+          submissionType: 'premission',  // normalized
+          submissionName: pickName('premission', goal, i),
+        };
+      })
     );
   }
 
@@ -210,7 +219,14 @@ export async function runMissions({ preMission, mission, postMission, tags = []
     missionName,
     maxTurns,
     retryLimit,
-    { domListLimit: domListLimitInfo?.value, debug: debugEnabled, resourceGuard, humanInput }
+    {
+      domListLimit: domListLimitInfo?.value,
+      automaticDomLimit: automaticDomLimitInfo.value,
+      storageStatePath: process.env.TESTRONAUT_STORAGE_STATE_PATH,
+      debug: debugEnabled,
+      resourceGuard,
+      humanInput,
+    }
   );
   if (!success) {
     console.log(`❌ Aborting after failed goal.`);

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

@@ -37,10 +37,22 @@ describe('CLI inspection commands', () => {
     const result = run(makeProject(), ['list', '--json']);
     expect(result.status).toBe(0);
     expect(JSON.parse(result.stdout).missions).toEqual([
-      { file: 'login.mission.js', tags: ['authentication', 'smoke'] },
+      { file: 'login.mission.js', tags: ['authentication', 'smoke'], selected: true },
     ]);
   });
 
+  it('applies tag filters to list output', () => {
+    const result = run(makeProject(), ['list', '--tag=checkout', '--json']);
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout).missions[0].selected).toBe(false);
+  });
+
+  it('does not discard a following inline flag', () => {
+    const result = run(makeProject(), ['--model=gpt-5.6', '--turns=30', '--dry-run', '--json']);
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout).missions[0].file).toBe('missions/login.mission.js');
+  });
+
   it('reports effective config without exposing the session token', () => {
     const result = run(makeProject(), ['config', '--json']);
     expect(result.status).toBe(0);
@@ -74,4 +86,17 @@ describe('CLI inspection commands', () => {
     expect(result.status).toBe(0);
     expect(JSON.parse(result.stdout).missions[0].missionName).toBe('https://example.test');
   });
+
+  it('records shared-auth session mode in the report', () => {
+    const cwd = makeProject();
+    fs.writeFileSync(path.join(cwd, 'missions', 'login.mission.js'), [
+      'export const tags = ["authentication"];',
+      'export async function executeMission() {',
+      '  return { missionName: "login", submissionType: "mission", status: "passed", steps: [] };',
+      '}',
+    ].join('\n'));
+    const result = run(cwd, ['--session=shared-auth', '--json', '--quiet']);
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout).session).toEqual({ mode: 'shared-auth' });
+  });
 });

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

@@ -15,13 +15,19 @@ describe('model helpers', () => {
       'gpt-5.6-luna',
     ]));
     expect(openAIModels()).not.toContain('gpt-5.3');
-    expect(geminiModels()).toContain('gemini-2.5-flash');
+    expect(geminiModels()).toEqual(expect.arrayContaining([
+      'gemini-3.8-flash',
+      'gemini-3.5-flash-lite',
+      'gemini-3.1-pro-preview',
+      'gemini-2.5-flash',
+    ]));
     expect(anthropicModels()).toContain('claude-sonnet-5');
   });
 
   it('recognizes known models by provider', () => {
     expect(isKnownModel('openai', 'gpt-4.1-mini')).toBe(true);
     expect(isKnownModel('gemini', 'gpt-4.1-mini')).toBe(false);
+    expect(isKnownModel('gemini', 'gemini-3.8-flash')).toBe(true);
     expect(isKnownModel('anthropic', 'claude-sonnet-5')).toBe(true);
   });
 

package/tests/coreTests/agent.test.js

@@ -6,6 +6,7 @@ vi.mock('../../tools/chromeBrowser.js', () => {
   function ChromeBrowser() {}
   ChromeBrowser.prototype.start = async function () {};
   ChromeBrowser.prototype.close = async function () {};
+  ChromeBrowser.prototype.probe = async function () { return { passed: true }; };
   return { ChromeBrowser };
 });
 
@@ -17,6 +18,7 @@ vi.mock('../../core/turnLoop.js', () => ({
 import { ChromeBrowser } from '../../tools/chromeBrowser.js';
 import { turnLoop } from '../../core/turnLoop.js';
 import { runAgent } from '../../core/agent.js';
+import { resetLaunchProtocols } from '../../core/launchProtocol.js';
 
 let startSpy, closeSpy;
 
@@ -26,6 +28,8 @@ describe('core/agent.runAgent', () => {
     startSpy = vi.spyOn(ChromeBrowser.prototype, 'start').mockResolvedValue();
     closeSpy = vi.spyOn(ChromeBrowser.prototype, 'close').mockResolvedValue();
     vi.clearAllMocks();
+    resetLaunchProtocols();
+    delete process.env.TESTRONAUT_SESSION_MODE;
   });
 
   afterEach(() => {
@@ -104,6 +108,63 @@ describe('core/agent.runAgent', () => {
     expect(res2[0].steps[0].result).toBe('SUCCESS: step2');
   });
 
+  it('attaches telemetry recorded during each goal to that result', async () => {
+    turnLoop.mockImplementationOnce(async (browser, messages, maxTurns, ct, rc, cs, ctx) => {
+      ctx.groundControl.telemetry.push({ kind: 'note', text: 'durable observation' });
+      return { success: true };
+    });
+    const [result] = await runAgent([{ goal: 'Observe' }], 'Telemetry', 3);
+    expect(result.telemetry).toEqual([{ kind: 'note', text: 'durable observation' }]);
+  });
+
+  it('reuses a completed launch protocol after a passing shared-auth probe', async () => {
+    process.env.TESTRONAUT_SESSION_MODE = 'shared-auth';
+    const probeSpy = vi.spyOn(ChromeBrowser.prototype, 'probe').mockResolvedValue({
+      passed: true,
+      url: 'https://example.test/dashboard',
+    });
+    const goal = {
+      goal: 'Log in',
+      submissionType: 'premission',
+      launchProtocol: { id: 'authenticated:user', probe: { selector: '#dashboard' } },
+    };
+    turnLoop.mockResolvedValueOnce({ success: true });
+    await runAgent([goal], 'First', 3);
+    turnLoop.mockResolvedValueOnce({ success: true });
+    const [reused] = await runAgent([
+      goal,
+      { goal: 'Use the current dashboard', submissionType: 'mission' },
+    ], 'Second', 3);
+
+    expect(turnLoop).toHaveBeenCalledTimes(2);
+    expect(probeSpy).toHaveBeenCalledWith({ selector: '#dashboard' });
+    expect(reused.launchProtocol).toEqual({ id: 'authenticated:user', status: 'reused', probe: 'passed' });
+    expect(reused.steps[0].tokensUsed).toBe(0);
+    const mainMessages = turnLoop.mock.calls[1][1];
+    expect(mainMessages[0].content).toContain('https://example.test/dashboard');
+    expect(mainMessages[0].content).toContain('"loggedIn": true');
+    probeSpy.mockRestore();
+  });
+
+  it('falls back to the original preMission when a reuse probe fails', async () => {
+    process.env.TESTRONAUT_SESSION_MODE = 'shared-auth';
+    const goal = {
+      goal: 'Log in',
+      submissionType: 'premission',
+      launchProtocol: { id: 'authenticated:user', probe: { selector: '#dashboard' } },
+    };
+    turnLoop.mockResolvedValue({ success: true });
+    await runAgent([goal], 'First', 3);
+    const probeSpy = vi.spyOn(ChromeBrowser.prototype, 'probe').mockResolvedValueOnce({ passed: false, reason: 'signed out' });
+    const [executed] = await runAgent([goal], 'Second', 3);
+
+    expect(turnLoop).toHaveBeenCalledTimes(2);
+    expect(executed.launchProtocol).toEqual({
+      id: 'authenticated:user', status: 'executed', probe: 'failed', reason: 'signed out',
+    });
+    probeSpy.mockRestore();
+  });
+
   it('includes missionName and submission metadata in results', async () => {
     turnLoop.mockResolvedValueOnce({ success: true });
 

package/tests/coreTests/config.test.js

@@ -13,6 +13,7 @@ import {
   resolveTurnLimits,
   enforceTurnBudget,
   getDomListLimit,
+  getAutomaticDomLimit,
   getResourceGuardConfig,
   getHumanInputConfig,
 } from '../../core/config.js';
@@ -21,6 +22,15 @@ describe('core/config', () => {
   beforeEach(() => {
     vi.resetAllMocks();
     delete process.env.STRICT_LIMITS;
+    delete process.env.TESTRONAUT_AUTO_DOM_LIMIT;
+  });
+
+  describe('getAutomaticDomLimit', () => {
+    it('uses config and clamps unsafe values', () => {
+      expect(getAutomaticDomLimit({ dom: { automaticLimit: 9000 } })).toMatchObject({ value: 9000, source: 'config' });
+      process.env.TESTRONAUT_AUTO_DOM_LIMIT = '250000';
+      expect(getAutomaticDomLimit({})).toMatchObject({ value: 100000, source: 'env', clamped: true });
+    });
   });
 
   describe('loadConfig', () => {

package/tests/coreTests/launchProtocol.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import {
+  launchProtocol,
+  unwrapLaunchProtocol,
+  hasCompletedLaunchProtocol,
+  markLaunchProtocolCompleted,
+  resetLaunchProtocols,
+} from '../../core/launchProtocol.js';
+
+describe('launchProtocol', () => {
+  beforeEach(() => resetLaunchProtocols());
+
+  it('wraps ordinary mission text without changing string coercion', () => {
+    const wrapped = launchProtocol('Log in', {
+      id: 'authenticated:user',
+      probe: { url: 'https://example.test', selector: '#dashboard' },
+    });
+    expect(String(wrapped)).toBe('Log in');
+    expect(unwrapLaunchProtocol(wrapped)).toEqual({
+      goal: 'Log in',
+      protocol: {
+        id: 'authenticated:user',
+        probe: { url: 'https://example.test', selector: '#dashboard' },
+      },
+    });
+  });
+
+  it('tracks completed protocol ids for one process run', () => {
+    expect(hasCompletedLaunchProtocol('auth')).toBe(false);
+    markLaunchProtocolCompleted('auth');
+    expect(hasCompletedLaunchProtocol('auth')).toBe(true);
+  });
+
+  it('rejects incomplete metadata', () => {
+    expect(() => launchProtocol('x', { probe: { selector: '#ready' } })).toThrow(/id/);
+    expect(() => launchProtocol('x', { id: 'ready', probe: {} })).toThrow(/selector or text/);
+  });
+});

package/tests/coreTests/turnLoop.test.js

@@ -205,6 +205,27 @@ describe('turnLoop', () => {
     expect(step1.result).toBe('✅ Passed');
     expect(shared.chromeToolSpies.click_text).toHaveBeenCalledTimes(1);
     expect(shared.chromeToolSpies.get_dom).toHaveBeenCalled();
+    expect(shared.chromeToolSpies.get_dom).toHaveBeenCalledWith(
+      browser,
+      expect.objectContaining({ limit: 15000, exclude: true }),
+      expect.any(Object)
+    );
+
+    const secondRequestMessages = shared.chatMock.mock.calls[1][0].messages;
+    const clickCallIndex = secondRequestMessages.findIndex(message =>
+      message.role === 'assistant' && message.tool_calls?.[0]?.function?.name === 'click_text'
+    );
+    expect(secondRequestMessages.slice(clickCallIndex, clickCallIndex + 4).map(message => ({
+      role: message.role,
+      tool: message.tool_calls?.[0]?.function?.name ?? message.name,
+    }))).toEqual([
+      { role: 'assistant', tool: 'click_text' },
+      { role: 'tool', tool: 'click_text' },
+      { role: 'assistant', tool: 'get_dom' },
+      { role: 'tool', tool: 'get_dom' },
+    ]);
+    expect(JSON.parse(secondRequestMessages[clickCallIndex + 2].tool_calls[0].function.arguments))
+      .toEqual({ limit: 15000, exclude: true });
 
     const step2 = res.steps[1];
     expect(step2.result).toMatch(/Success/);

package/tests/llmTests/geminiProvider.test.js

@@ -146,14 +146,17 @@ describe('GeminiProvider', () => {
 
     // 2) Assistant tool call → model role with functionCall
     expect(c[1].role).toBe('model');
-    expect(c[1].parts[0].functionCall).toEqual({ name: 'search', args: { q: 'x' } });
+    expect(c[1].parts[0]).toEqual({
+      functionCall: { name: 'search', args: { q: 'x' } },
+      thoughtSignature: 'skip_thought_signature_validator',
+    });
 
-    // 3) Tool result → user role with JSON marker
+    // 3) Tool result → structured Gemini function response
     expect(c[2].role).toBe('user');
-    const toolJson = JSON.parse(c[2].parts[0].text);
-    expect(toolJson._tool_result).toBe(true);
-    expect(toolJson.tool_call_id).toBe('1');
-    expect(toolJson.name).toBe('search');
+    expect(c[2].parts[0].functionResponse).toEqual({
+      name: 'search',
+      response: { results: [1, 2, 3] },
+    });
 
     // 4) Final assistant text → model role with text
     expect(c[3].role).toBe('model');
@@ -168,7 +171,10 @@ describe('GeminiProvider', () => {
           {
             content: {
               parts: [
-                { functionCall: { name: 'open', args: { url: 'https://example.com' } } },
+                {
+                  functionCall: { name: 'open', args: { url: 'https://example.com' } },
+                  thoughtSignature: 'encrypted-signature',
+                },
                 { text: 'Ok!' },
               ],
             },
@@ -189,11 +195,87 @@ describe('GeminiProvider', () => {
     expect(Array.isArray(message.tool_calls)).toBe(true);
     expect(message.tool_calls[0].function.name).toBe('open');
     expect(JSON.parse(message.tool_calls[0].function.arguments)).toEqual({ url: 'https://example.com' });
+    expect(message.provider_metadata.gemini.parts[0].thoughtSignature).toBe('encrypted-signature');
 
     expect(usage.total_tokens).toBe(999);
     expect(usage.providerRaw).toEqual({ totalTokenCount: 999, other: 'meta' });
   });
 
+  it('replays Gemini response parts so thought signatures survive tool loops', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+    const signedPart = {
+      functionCall: { name: 'click', args: { selector: '#submit' } },
+      thoughtSignature: 'opaque-signature',
+    };
+
+    await prov.chat({
+      model: 'gemini-3.8-flash',
+      messages: [
+        { role: 'user', content: 'Submit the form' },
+        {
+          role: 'assistant',
+          content: '',
+          tool_calls: [{ type: 'function', function: { name: 'click', arguments: '{"selector":"#submit"}' } }],
+          provider_metadata: { gemini: { parts: [signedPart] } },
+        },
+        { role: 'tool', name: 'click', content: 'Clicked' },
+      ],
+    });
+
+    expect(shared.lastContents[1]).toEqual({ role: 'model', parts: [signedPart] });
+    expect(shared.lastContents[2].parts[0].functionResponse).toEqual({
+      name: 'click',
+      response: { result: 'Clicked' },
+    });
+  });
+
+  it('signs deterministic client-injected function calls for Gemini 3 history', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    await prov.chat({
+      model: 'gemini-3.8-flash',
+      messages: [
+        { role: 'user', content: 'Open the dashboard' },
+        {
+          role: 'assistant',
+          content: '',
+          tool_calls: [{
+            id: 'synthetic-dom',
+            type: 'function',
+            function: { name: 'get_dom', arguments: '{"selector":"main"}' },
+          }],
+        },
+        { role: 'tool', tool_call_id: 'synthetic-dom', name: 'get_dom', content: '<main>Dashboard</main>' },
+      ],
+    });
+
+    expect(shared.lastContents[1].parts[0]).toEqual({
+      functionCall: { name: 'get_dom', args: { selector: 'main' } },
+      thoughtSignature: 'skip_thought_signature_validator',
+    });
+  });
+
+  it('adds the synthetic signature only to the first parallel function call', async () => {
+    const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
+
+    await prov.chat({
+      model: 'gemini-3.8-flash',
+      messages: [
+        { role: 'user', content: 'Inspect both regions' },
+        {
+          role: 'assistant',
+          tool_calls: [
+            { type: 'function', function: { name: 'get_dom', arguments: '{"selector":"main"}' } },
+            { type: 'function', function: { name: 'get_dom', arguments: '{"selector":"nav"}' } },
+          ],
+        },
+      ],
+    });
+
+    expect(shared.lastContents[1].parts[0].thoughtSignature).toBe('skip_thought_signature_validator');
+    expect(shared.lastContents[1].parts[1].thoughtSignature).toBeUndefined();
+  });
+
   it('supports image parts (encoded to inlineData)', async () => {
     const prov = new GeminiProvider({ apiKey: 'gk-xyz' });
 

package/tests/runnerTests/testronaut.test.js

@@ -11,15 +11,16 @@ vi.mock('../../core/config.js', () => ({
   enforceTurnBudget: vi.fn(),
   getRetryLimit: vi.fn(),
   getDomListLimit: vi.fn(),
+  getAutomaticDomLimit: vi.fn(),
   getResourceGuardConfig: vi.fn(),
   getHumanInputConfig: vi.fn(),
 }));
 
 import { runAgent } from '../../core/agent.js';
-import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getResourceGuardConfig, getHumanInputConfig } from '../../core/config.js';
+import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getAutomaticDomLimit, getResourceGuardConfig, getHumanInputConfig } from '../../core/config.js';
 
 // Adjust the import path if your file lives elsewhere
-import { runMissions, __test__ as testronautInternals } from '../../runner/testronaut.js';
+import { runMissions, launchProtocol, __test__ as testronautInternals } from '../../runner/testronaut.js';
 
 describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
   const OLD_ENV = { ...process.env };
@@ -29,6 +30,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
     // 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 });
+    getAutomaticDomLimit.mockReturnValue({ value: 15000, source: 'default', clamped: false });
     getResourceGuardConfig.mockReturnValue({ enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] });
     getHumanInputConfig.mockReturnValue({ enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false });
   });
@@ -58,13 +60,38 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
       expect.stringContaining('Clamping to 200')
     );
     expect(runAgent).toHaveBeenCalledWith(
-      expect.any(Array), 'Budgeted Run', 200, 2, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } }
+      expect.any(Array), 'Budgeted Run', 200, 2, { domListLimit: 3, automaticDomLimit: 15000, storageStatePath: undefined, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } }
     );
 
     warn.mockRestore();
     log.mockRestore();
   });
 
+  it('unwraps launch protocols while preserving preMission authoring', async () => {
+    loadConfig.mockResolvedValue({ maxTurns: 20 });
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 20,
+      limits: { softMaxTurns: 50, hardMaxTurns: 200, hardMinTurns: 5 },
+      notes: [],
+    });
+    runAgent.mockResolvedValue([{ steps: [{ result: 'SUCCESS' }], status: 'passed' }]);
+    const protocol = launchProtocol('Log in', {
+      id: 'authenticated:user',
+      probe: { url: 'https://example.test', selector: '#dashboard' },
+    });
+
+    await runMissions({ preMission: protocol, mission: 'Test dashboard' }, 'Protocol mission');
+    const goals = runAgent.mock.calls[0][0];
+    expect(goals[0]).toMatchObject({
+      goal: 'Log in',
+      submissionType: 'premission',
+      launchProtocol: {
+        id: 'authenticated:user',
+        probe: { url: 'https://example.test', selector: '#dashboard' },
+      },
+    });
+  });
+
   it('does not warn when no notes are returned', async () => {
     loadConfig.mockResolvedValue({ maxTurns: 20 });
     enforceTurnBudget.mockReturnValue({
@@ -85,7 +112,7 @@ 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, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } });
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Clean', 20, 3, { domListLimit: 3, automaticDomLimit: 15000, storageStatePath: undefined, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } });
 
     warn.mockRestore();
     log.mockRestore();
@@ -213,7 +240,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, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } });
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15, 2, { domListLimit: 3, automaticDomLimit: 15000, storageStatePath: undefined, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } });
 
     log.mockRestore();
   });
@@ -252,7 +279,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
 
     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'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } });
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Debug Mission', 20, 2, { domListLimit: 3, automaticDomLimit: 15000, storageStatePath: undefined, debug: true, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] }, humanInput: { enabled: true, timeoutSeconds: 60, source: { enabled: 'default', timeout: 'default' }, clamped: false } });
 
     log.mockRestore();
   });