testronaut 1.6.1 → 1.7.0

package/bin/init.js

@@ -6,7 +6,7 @@
  *   writing a provider/model-aware config, and scaffolding a .env file.
  *
  * Responsibilities:
- *   1) Ask the user for an LLM provider (OpenAI or Gemini).
+ *   1) Ask the user for an LLM provider (OpenAI, Gemini, or Anthropic Claude).
  *   2) Ask for a provider-specific model (keeps prior choice when re-run).
  *   3) Write `testronaut-config.json` and an initial `.env` placeholder.
  *   4) Ensure folder structure and create a welcome mission.
@@ -33,9 +33,11 @@ import {
   defaultConfig,
   makeEnvTemplate,
   geminiModels,
+  anthropicModels,
   pickInitialIndex
 } from './initHelpers.js';
 import { DEFAULT_OPENAI_MODEL, OPENAI_MODELS } from '../llm/openAI/models.js';
+import { ANTHROPIC_MODELS, DEFAULT_ANTHROPIC_MODEL } from '../llm/anthropic/models.js';
 
 export async function initializeTestronautProject() {
   // ─────────────────────────────────────────────
@@ -43,7 +45,6 @@ export async function initializeTestronautProject() {
   // ─────────────────────────────────────────────
   const root = process.cwd();
   const missionsDir = path.join(root, 'missions');
-  const reportsDir = path.join(missionsDir, 'mission_reports');
   const configPath = path.join(root, 'testronaut-config.json');
   const envPath = path.join(root, '.env');
 
@@ -70,10 +71,10 @@ export async function initializeTestronautProject() {
       choices: [
         { title: 'OpenAI (GPT family)', value: 'openai' },
         { title: 'Google Gemini', value: 'gemini' },
-        // Future: add Anthropic, Mistral, etc.
+        { title: 'Anthropic Claude', value: 'anthropic' },
       ],
       // If user re-runs init before writing config, preselect known value.
-      initial: ['openai', 'gemini'].indexOf(config.provider ?? 'openai')
+      initial: Math.max(0, ['openai', 'gemini', 'anthropic'].indexOf(config.provider ?? 'openai'))
     });
 
     // Persist provider explicitly to config.
@@ -129,6 +130,19 @@ export async function initializeTestronautProject() {
       });
 
       config.model = geminiModel;
+    } else if (llmProvider === 'anthropic') {
+      const models = anthropicModels();
+      const { anthropicModel } = await prompts({
+        type: 'select',
+        name: 'anthropicModel',
+        message: 'Select an Anthropic Claude model:',
+        choices: ANTHROPIC_MODELS.map(model => ({
+          title: `${model.label} (${model.description})`,
+          value: model.id,
+        })),
+        initial: pickInitialIndex(models, config.model, DEFAULT_ANTHROPIC_MODEL),
+      });
+      config.model = anthropicModel;
     }
 
     // ─────────────────────────────────────────────
@@ -139,6 +153,9 @@ export async function initializeTestronautProject() {
     config.outputDir = config.outputDir || defaults.outputDir;
     config.projectName = config.projectName || defaults.projectName;
     config.maxTurns = config.maxTurns ?? defaults.maxTurns;
+    config.tags = config.tags ?? defaults.tags;
+    config.tagMatch = config.tagMatch ?? defaults.tagMatch;
+    config.addTags = config.addTags ?? defaults.addTags;
     config.dom = { ...defaults.dom, ...(config.dom || {}) };
     config.resourceGuard = { ...defaults.resourceGuard, ...(config.resourceGuard || {}) };
     config.humanInput = { ...defaults.humanInput, ...(config.humanInput || {}) };
@@ -181,6 +198,18 @@ export async function initializeTestronautProject() {
 
 📌 If you plan to use tools/function-calling or images, make sure your account has access to those features.
 
+✅ Ready to write missions in \`missions/\`. Try:
+
+    testronaut welcome.mission.js
+`);
+    } else if (config.provider === 'anthropic') {
+      console.log(`
+🔧 Setup Complete!
+
+👉 Ensure your .env file contains your Anthropic key:
+
+    ANTHROPIC_API_KEY=sk-ant-...
+
 ✅ Ready to write missions in \`missions/\`. Try:
 
     testronaut welcome.mission.js
@@ -197,12 +226,13 @@ export async function initializeTestronautProject() {
   // ─────────────────────────────────────────────
   // STEP 5: Ensure folder structure exists (safe to call every run)
   // ─────────────────────────────────────────────
+  const reportsDir = path.resolve(root, config.outputDir || 'missions/mission_reports');
   if (!fs.existsSync(missionsDir)) {
     fs.mkdirSync(missionsDir);
     console.log('📁 Created missions/');
   }
   if (!fs.existsSync(reportsDir)) {
     fs.mkdirSync(reportsDir);
-    console.log('📁 Created missions/mission_reports/');
+    console.log(`📁 Created ${path.relative(root, reportsDir) || reportsDir}/`);
   }
 }

package/bin/initHelpers.js

@@ -26,6 +26,7 @@
  */
 
 import { OPENAI_MODELS } from '../llm/openAI/models.js';
+import { ANTHROPIC_MODELS } from '../llm/anthropic/models.js';
 
 /**
  * Ensures backward compatibility for older configs where
@@ -76,7 +77,7 @@ export function defaultConfig(rootBasename) {
  * Returns a provider-specific .env template string.
  * This scaffolds a safe placeholder API key for the user to fill in manually.
  *
- * @param {'openai'|'gemini'} provider - The chosen LLM provider
+ * @param {'openai'|'gemini'|'anthropic'} provider - The chosen LLM provider
  * @returns {string} A multiline template for the .env file
  */
 export function makeEnvTemplate(provider) {
@@ -88,6 +89,11 @@ OPENAI_API_KEY=sk-...
   if (provider === 'gemini') {
     return `# Add your Google Gemini API key below
 GEMINI_API_KEY=AIza...
+`;
+  }
+  if (provider === 'anthropic') {
+    return `# Add your Anthropic API key below
+ANTHROPIC_API_KEY=sk-ant-...
 `;
   }
   return '';
@@ -115,17 +121,22 @@ export function geminiModels() {
   ];
 }
 
+export function anthropicModels() {
+  return ANTHROPIC_MODELS.map(({ id }) => id);
+}
+
 /**
  * Determines whether a given model name belongs to a known provider.
  *
- * @param {'openai'|'gemini'} provider - The LLM provider
+ * @param {'openai'|'gemini'|'anthropic'|'claude'} provider - The LLM provider
  * @param {string} model - The model name to check
  * @returns {boolean} True if the model is recognized for that provider
  */
 export function isKnownModel(provider, model) {
-  return provider === 'openai'
-    ? openAIModels().includes(model)
-    : geminiModels().includes(model);
+  if (provider === 'openai') return openAIModels().includes(model);
+  if (provider === 'gemini') return geminiModels().includes(model);
+  if (provider === 'anthropic' || provider === 'claude') return anthropicModels().includes(model);
+  return false;
 }
 
 /**

package/core/missionDiscovery.js

@@ -9,7 +9,7 @@ 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.
+ *   read the ./missions folder (non-recursive) for JavaScript/TypeScript missions.
  * - When missions is defined, apply root/include/exclude globs relative to root.
  *
  * @param {object} opts
@@ -21,13 +21,13 @@ export async function discoverMissionFiles({ cwd = process.cwd() } = {}) {
   const cfg = await loadConfig(cwd);
   const missionsCfg = cfg?.missions;
 
-  // Legacy behavior: no missions block → non-recursive *.mission.js in ./missions
+  // Legacy behavior remains non-recursive, now with first-class TypeScript support.
   if (!missionsCfg) {
     if (!fs.existsSync(defaultRoot)) {
       return { root: defaultRoot, files: [] };
     }
     const files = fs.readdirSync(defaultRoot)
-      .filter(f => f.endsWith('.mission.js'))
+      .filter(f => f.endsWith('.mission.js') || f.endsWith('.mission.ts'))
       .sort();
     return { root: defaultRoot, files };
   }

package/core/missionLoader.js

@@ -0,0 +1,16 @@
+import { createJiti } from 'jiti';
+
+// Mission files are user-authored configuration/code, so Testronaut owns their
+// module loading semantics instead of inheriting the host project's package type.
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  sourceMaps: true,
+});
+
+/**
+ * Load an ESM-style JavaScript or TypeScript mission regardless of whether the
+ * consuming project is ESM, CommonJS, or has no package.json `type` field.
+ */
+export async function loadMissionModule(modulePath) {
+  return jiti.import(modulePath);
+}

package/core/turnLoop.js

@@ -24,7 +24,7 @@
  *
  * Notes:
  *   - Provider-agnostic: routes all LLM calls through the `llmFactory` adapter layer.
- *   - OpenAI and Gemini both normalize responses to an OpenAI-like message format.
+ *   - All providers normalize responses to an OpenAI-like message format.
  *   - Token control is model-sensitive but provider-neutral.
  */
 
@@ -156,6 +156,8 @@ const FIRE_AND_FORGET_TOOLS = new Set([
   'switch_to_page',
   'close_current_page',
   'request_human_input',
+  'set_ground_control_state',
+  'record_mission_telemetry',
 ]);
 
 /**
@@ -252,9 +254,10 @@ export const turnLoop = async (
   const maxAttempts = retryLimitClamped + 1; // includes initial attempt
   ctx.groundControl = groundControl;
   const humanInput = ctx.humanInput || { enabled: true, timeoutSeconds: 60 };
-  const activeToolsSchema = humanInput.enabled === false
-    ? toolsSchema.filter(t => t?.function?.name !== 'request_human_input')
-    : toolsSchema;
+  const disabledTools = new Set();
+  if (humanInput.enabled === false) disabledTools.add('request_human_input');
+  if (process.env.TESTRONAUT_SCREENSHOTS === '0') disabledTools.add('screenshot');
+  const activeToolsSchema = toolsSchema.filter(t => !disabledTools.has(t?.function?.name));
   let agentMemory = { lastMenuExpanded: false, humanInput };
   ensureDocProgress(agentMemory, resourceGuardCfg);
   let turnRetries = 0;
@@ -433,7 +436,17 @@ export const turnLoop = async (
         let result;
         let errorMessage = null;
         try {
-          result = await CHROME_TOOL_MAP[fnName](browser, args, agentMemory);
+          if (fnName === 'set_ground_control_state') {
+            applyGroundControlUpdate(groundControl, args);
+            result = { ok: true, groundControl };
+          } else if (fnName === 'record_mission_telemetry') {
+            const recorded = recordGroundTelemetry(groundControl, args, { turn });
+            result = { ok: true, recorded };
+          } else {
+            const toolHandler = CHROME_TOOL_MAP[fnName];
+            if (typeof toolHandler !== 'function') throw new Error(`Unknown tool: ${fnName}`);
+            result = await toolHandler(browser, args, agentMemory);
+          }
           if (typeof result !== 'string') result = JSON.stringify(result ?? '');
         } catch (e) {
           errorMessage = `ERROR: ${e.message}`;
@@ -649,16 +662,6 @@ export const turnLoop = async (
           }
         }
 
-        if (fnName === 'set_ground_control_state') {
-          applyGroundControlUpdate(groundControl, args);
-          result = JSON.stringify({ ok: true, groundControl });
-        }
-
-        if (fnName === 'record_mission_telemetry') {
-          const recorded = recordGroundTelemetry(groundControl, args, { turn });
-          result = JSON.stringify({ ok: true, recorded });
-        }
-
         // Decide what to send back to the LLM for this tool.
         // - For "fire-and-forget" tools, send a tiny stub (OK/error) to avoid
         //   bloating context with large payloads (file JSON, etc.).

package/llm/anthropic/anthropicProvider.js

@@ -0,0 +1,119 @@
+import Anthropic from '@anthropic-ai/sdk';
+
+function textBlocks(content) {
+  const parts = Array.isArray(content) ? content : [{ type: 'text', text: content ?? '' }];
+  return parts.map(part => {
+    if (typeof part === 'string') return { type: 'text', text: part };
+    if (part?.type === 'image') {
+      return {
+        type: 'image',
+        source: {
+          type: 'base64',
+          media_type: part.mimeType,
+          data: Buffer.isBuffer(part.data) ? part.data.toString('base64') : String(part.data ?? ''),
+        },
+      };
+    }
+    return { type: 'text', text: part?.text ?? '' };
+  });
+}
+
+function appendMessage(messages, role, blocks) {
+  if (!blocks.length) return;
+  const previous = messages.at(-1);
+  if (previous?.role === role) {
+    const existing = Array.isArray(previous.content)
+      ? previous.content
+      : [{ type: 'text', text: previous.content }];
+    previous.content = [...existing, ...blocks];
+  } else {
+    messages.push({ role, content: blocks });
+  }
+}
+
+export function toAnthropicRequest(messages = []) {
+  const system = [];
+  const converted = [];
+
+  for (const message of messages) {
+    if (message.role === 'system') {
+      system.push(...textBlocks(message.content).filter(block => block.type === 'text'));
+      continue;
+    }
+
+    if (message.role === 'tool') {
+      appendMessage(converted, 'user', [{
+        type: 'tool_result',
+        tool_use_id: message.tool_call_id,
+        content: String(message.content ?? ''),
+      }]);
+      continue;
+    }
+
+    const blocks = textBlocks(message.content).filter(block => block.type !== 'text' || block.text);
+    if (message.role === 'assistant' && Array.isArray(message.tool_calls)) {
+      for (const call of message.tool_calls) {
+        let input = {};
+        try { input = JSON.parse(call.function?.arguments ?? '{}'); } catch { /* keep safe empty input */ }
+        blocks.push({
+          type: 'tool_use',
+          id: call.id,
+          name: call.function?.name,
+          input,
+        });
+      }
+    }
+    appendMessage(converted, message.role === 'assistant' ? 'assistant' : 'user', blocks);
+  }
+
+  return { system, messages: converted };
+}
+
+export function fromAnthropicMessage(response) {
+  const text = [];
+  const tool_calls = [];
+  for (const block of response?.content ?? []) {
+    if (block.type === 'text') text.push(block.text);
+    if (block.type === 'tool_use') {
+      tool_calls.push({
+        id: block.id,
+        type: 'function',
+        function: { name: block.name, arguments: JSON.stringify(block.input ?? {}) },
+      });
+    }
+  }
+  return {
+    role: 'assistant',
+    content: text.join(''),
+    tool_calls: tool_calls.length ? tool_calls : undefined,
+  };
+}
+
+export class AnthropicProvider {
+  constructor({ apiKey, maxTokens = 8192 } = {}) {
+    if (!apiKey) throw new Error('ANTHROPIC_API_KEY is required for Anthropic provider');
+    this.client = new Anthropic({ apiKey });
+    this.maxTokens = maxTokens;
+  }
+
+  async chat({ model, messages, tools }) {
+    const converted = toAnthropicRequest(messages);
+    const response = await this.client.messages.create({
+      model,
+      max_tokens: this.maxTokens,
+      system: converted.system.length ? converted.system : undefined,
+      messages: converted.messages,
+      tools: tools?.length ? tools.map(tool => ({
+        name: tool.function?.name ?? tool.name,
+        description: tool.function?.description ?? tool.description ?? '',
+        input_schema: tool.function?.parameters ?? tool.parameters ?? { type: 'object', properties: {} },
+      })) : undefined,
+    });
+
+    const usage = {
+      total_tokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
+      providerRaw: response.usage,
+    };
+    return { message: fromAnthropicMessage(response), usage };
+  }
+}

package/llm/anthropic/models.js

@@ -0,0 +1,7 @@
+export const DEFAULT_ANTHROPIC_MODEL = 'claude-sonnet-5';
+
+export const ANTHROPIC_MODELS = [
+  { id: 'claude-sonnet-5', label: 'Claude Sonnet 5', description: 'best balance of capability and speed' },
+  { id: 'claude-opus-5', label: 'Claude Opus 5', description: 'highest capability' },
+  { id: 'claude-haiku-4-5', label: 'Claude Haiku 4.5', description: 'fastest and most cost-efficient' },
+];

package/llm/llmFactory.js

@@ -26,12 +26,13 @@
 
 import { OpenAIProvider } from './openAI/openaiProvider.js';
 import { GeminiProvider } from './gemini/geminiProvider.js';
+import { AnthropicProvider } from './anthropic/anthropicProvider.js';
 
 /**
  * Return an adapter implementing:
  *   chat({ model, messages, tools }) -> Promise<{ message, usage }>
  *
- * @param {string} providerName - 'openai' | 'gemini'
+ * @param {string} providerName - 'openai' | 'gemini' | 'anthropic' | 'claude'
  * @param {object} [opts]       - Optional overrides (e.g., { apiKey, baseURL, ... })
  * @returns {{ chat: Function }} provider adapter
  */
@@ -44,6 +45,10 @@ export function getLLM(providerName, opts = {}) {
     case 'gemini':
       return new GeminiProvider({ apiKey: process.env.GEMINI_API_KEY, ...opts });
 
+    case 'anthropic':
+    case 'claude':
+      return new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY, ...opts });
+
     default:
       throw new Error(`Unsupported LLM provider: ${providerName}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testronaut",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "main": "./runner/testronaut.js",
   "bin": {
     "testronaut": "bin/cli.js"
@@ -24,12 +24,14 @@
     "url": "https://github.com/mission-testronaut/testronaut-cli"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.124.0",
     "@dqbd/tiktoken": "^1.0.21",
     "@google/generative-ai": "^0.24.1",
     "cheerio": "^1.1.0",
     "dotenv": "^17.2.0",
     "fast-glob": "^3.3.3",
     "inquirer": "^12.9.1",
+    "jiti": "^2.7.0",
     "node-fetch": "^3.3.2",
     "openai": "^6.39.0",
     "playwright": "^1.54.1",

package/runner/testronaut.js

@@ -23,9 +23,11 @@
  */
 
 
+// Mission modules commonly interpolate project .env values at module load time.
+// Keep env loading eager even though the browser/agent import below is lazy.
+import 'dotenv/config';
 import fs from 'fs';
 import path from 'path';
-import { runAgent } from '../core/agent.js';
 import { redactPasswordInText } from '../core/redaction.js';
 import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getResourceGuardConfig, getHumanInputConfig } from '../core/config.js';
 import { normalizeTags } from '../core/tags.js';
@@ -202,6 +204,7 @@ export async function runMissions({ preMission, mission, postMission, tags = []
   );
 
   // 3) Execute
+  const { runAgent } = await import('../core/agent.js');
   const success = await runAgent(
     goals,
     missionName,

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

@@ -1,10 +1,22 @@
-import { describe, it, expect } from 'vitest';
+import { afterEach, describe, it, expect } from 'vitest';
 import path from 'path';
 import fs from 'fs';
+import os from 'os';
 
 // Import helper exports from cli.js
 import { __test__ } from '../../bin/cli.js';
 
+const tempDirs = [];
+const makeTempDir = (prefix) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+};
+
+afterEach(() => {
+  while (tempDirs.length) fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+});
+
 describe('cli helpers', () => {
   it('guessMimeType returns expected types', () => {
     const { guessMimeType } = __test__;
@@ -22,7 +34,7 @@ describe('cli helpers', () => {
 
   it('findLatestReportPair finds latest html/json', () => {
     const { findLatestReportPair } = __test__;
-    const tmp = fs.mkdtempSync(path.join(process.cwd(), 'testronaut-report-'));
+    const tmp = makeTempDir('testronaut-report-');
     const r1 = path.join(tmp, 'run_100.html');
     const r2 = path.join(tmp, 'run_200.html');
     fs.writeFileSync(r1, 'a');
@@ -34,6 +46,67 @@ describe('cli helpers', () => {
     expect(latest?.jsonFile).toBe('run_200.json');
   });
 
+  it('resolves bare mission names from the missions root and direct paths from cwd', () => {
+    const { resolveMissionPath } = __test__;
+    const cwd = '/tmp/project';
+    const missionsRoot = '/tmp/project/missions';
+    expect(resolveMissionPath('login.mission.js', { cwd, missionsRoot }))
+      .toBe('/tmp/project/missions/login.mission.js');
+    expect(resolveMissionPath('missions/login.mission.js', { cwd, missionsRoot }))
+      .toBe('/tmp/project/missions/login.mission.js');
+    expect(resolveMissionPath('../shared/login.mission.js', { cwd, missionsRoot }))
+      .toBe('/tmp/shared/login.mission.js');
+  });
+
+  it('collects only unique screenshots referenced by a report', () => {
+    const { collectReportScreenshotNames, collectReportScreenshotPaths } = __test__;
+    const report = { missions: [
+      { steps: [{ screenshotPath: './screenshots/one.png' }, { screenshotPath: './screenshots/two.jpg' }] },
+      { steps: [{ screenshotPath: './screenshots/one.png' }, { events: [] }] },
+    ] };
+    expect(collectReportScreenshotNames(report)).toEqual(['one.png', 'two.jpg']);
+    expect(collectReportScreenshotPaths(report)).toEqual(['screenshots/one.png', 'screenshots/two.jpg']);
+  });
+
+  it('preserves run-specific screenshot paths', () => {
+    const { collectReportScreenshotPaths } = __test__;
+    const report = { missions: [{ steps: [
+      { screenshotPath: './screenshots/run_123/one.png' },
+    ] }] };
+    expect(collectReportScreenshotPaths(report)).toEqual(['screenshots/run_123/one.png']);
+  });
+
+  it('resolves configured report directories and suggests close mission names', () => {
+    const { resolveReportDir, closestMissionMatch } = __test__;
+    expect(resolveReportDir({ outputDir: 'artifacts/reports' }, '/tmp/project'))
+      .toBe('/tmp/project/artifacts/reports');
+    expect(closestMissionMatch('logn.mission.js', ['checkout.mission.js', 'login.mission.js']))
+      .toBe('login.mission.js');
+  });
+
+  it('resolves selected reports by run id, filename, and direct path', () => {
+    const { resolveReportFile } = __test__;
+    const tmp = makeTempDir('testronaut-selected-report-');
+    const reportDir = path.join(tmp, 'reports');
+    fs.mkdirSync(reportDir);
+    const report = path.join(reportDir, 'run_123.json');
+    fs.writeFileSync(report, '{}');
+
+    expect(resolveReportFile('run_123', reportDir, tmp)).toBe(report);
+    expect(resolveReportFile('run_123.json', reportDir, tmp)).toBe(report);
+    expect(resolveReportFile(report, reportDir, tmp)).toBe(report);
+  });
+
+  it('builds a redacted effective config with source information', () => {
+    const { buildEffectiveConfig } = __test__;
+    const effective = buildEffectiveConfig({
+      provider: 'openai', model: 'gpt-5.6', outputDir: 'artifacts', sessionToken: 'secret',
+    }, '/tmp/project');
+    expect(effective.outputDir).toEqual({ value: '/tmp/project/artifacts', source: 'config' });
+    expect(effective.authenticated).toBe(true);
+    expect(JSON.stringify(effective)).not.toContain('secret');
+  });
+
   it('parses booleans in a tolerant way', () => {
     const { parseBool } = __test__;
     expect(parseBool('true')).toBe(true);

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

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const cliPath = fileURLToPath(new URL('../../bin/cli.js', import.meta.url));
+const tempDirs = [];
+
+function makeProject() {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-cli-integration-'));
+  tempDirs.push(cwd);
+  fs.mkdirSync(path.join(cwd, 'missions'));
+  fs.writeFileSync(path.join(cwd, 'missions', 'login.mission.js'), [
+    'export const tags = ["authentication", "smoke"];',
+    'export function executeMission() { throw new Error("must not execute"); }',
+  ].join('\n'));
+  fs.writeFileSync(path.join(cwd, 'testronaut-config.json'), JSON.stringify({
+    provider: 'openai', model: 'gpt-5.6', outputDir: 'artifacts/reports', sessionToken: 'private',
+  }));
+  return cwd;
+}
+
+function run(cwd, args) {
+  const result = spawnSync(process.execPath, [cliPath, ...args], { cwd, encoding: 'utf8' });
+  if (result.error) throw result.error;
+  return result;
+}
+
+afterEach(() => {
+  while (tempDirs.length) fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+});
+
+describe('CLI inspection commands', () => {
+  it('lists mission tags without executing the mission', () => {
+    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'] },
+    ]);
+  });
+
+  it('reports effective config without exposing the session token', () => {
+    const result = run(makeProject(), ['config', '--json']);
+    expect(result.status).toBe(0);
+    const output = JSON.parse(result.stdout);
+    expect(output.outputDir.value).toMatch(/artifacts[/\\]reports$/);
+    expect(output.authenticated).toBe(true);
+    expect(result.stdout).not.toContain('private');
+  });
+
+  it('suggests a close mission name and exits nonzero during dry-run', () => {
+    const result = run(makeProject(), ['logn.mission.js', '--dry-run', '--json']);
+    expect(result.status).toBe(1);
+    expect(JSON.parse(result.stdout).missions[0]).toMatchObject({
+      status: 'missing', suggestion: 'login.mission.js',
+    });
+  });
+
+  it('loads project .env values before evaluating mission modules', () => {
+    const cwd = makeProject();
+    fs.writeFileSync(path.join(cwd, '.env'), 'MISSION_DESTINATION=https://example.test\n');
+    fs.writeFileSync(path.join(cwd, 'missions', 'login.mission.js'), [
+      'const destination = process.env.MISSION_DESTINATION;',
+      'export const tags = ["authentication"];',
+      'export async function executeMission() {',
+      '  return { missionName: destination, status: "passed", steps: [] };',
+      '}',
+    ].join('\n'));
+
+    const result = run(cwd, ['--tags', 'authentication', '--json', '--quiet']);
+
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout).missions[0].missionName).toBe('https://example.test');
+  });
+});