explorbot 0.2.4 → 0.2.5

package/bin/explorbot-cli.ts

@@ -15,7 +15,7 @@ import { remote } from '../src/remote.js';
 import { Stats } from '../src/stats.js';
 import { Plan } from '../src/test-plan.js';
 import { getCliName } from '../src/utils/cli-name.ts';
-import { log, setPreserveConsoleLogs } from '../src/utils/logger.js';
+import { isVerboseMode, log, setPreserveConsoleLogs, setQuietMode } from '../src/utils/logger.js';
 import { jsonToTable } from '../src/utils/markdown-parser.js';
 import { parseMarkdownToTerminal } from '../src/utils/markdown-terminal.js';
 import { type NextStepSection, printNextSteps, relativeToCwd } from '../src/utils/next-steps.ts';
@@ -436,6 +436,23 @@ addCommonOptions(
   await cmd.execute(args);
 });
 
+program
+  .command('config [url]')
+  .description('Show models, config file and paths used by this run')
+  .option('-c, --config <path>', 'Path to configuration file')
+  .option('-p, --path <path>', 'Working directory path')
+  .option('--json', 'Print the resolved config as JSON')
+  .action(async (url, options) => {
+    setQuietMode(!isVerboseMode());
+    const { ConfigCommand } = await import('../src/commands/config-command.js');
+    try {
+      console.log(await ConfigCommand.summary({ config: options.config, path: options.path, url, json: options.json }));
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
 program
   .command('init')
   .description('Initialize configuration for a project or for this machine')
@@ -912,11 +929,6 @@ ${rows}
 `;
 };
 
-const addEnvHelp = (cmd: Command) => {
-  cmd.addHelpText('after', envHelp);
-  for (const sub of cmd.commands) addEnvHelp(sub);
-};
-
-addEnvHelp(program);
+program.addHelpText('after', envHelp);
 
 program.parse();

package/boat/api-tester/src/cli.ts

@@ -1,9 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { Command } from 'commander';
+import { ConfigCommand } from '../../../src/commands/config-command.ts';
+import { listSites } from '../../../src/global-config.ts';
 import { setPreserveConsoleLogs } from '../../../src/utils/logger.ts';
 import { getStyles } from './ai/chief/styles.ts';
 import { ApiBot, type ApibotOptions } from './apibot.ts';
+import { ApibotConfigParser } from './config.ts';
 
 function buildOptions(options: any): ApibotOptions {
   return {
@@ -82,6 +85,20 @@ export function createApiCommands(name = 'api'): Command {
     }
   });
 
+  addCommonOptions(cmd.command('config [endpoint]').description('Show models, config file and paths used by this run'))
+    .option('--json', 'Print the resolved config as JSON')
+    .action(async (endpoint, options) => {
+      const parser = ApibotConfigParser.getInstance();
+      const [site] = listSites();
+      try {
+        const config = await parser.loadConfig({ config: options.config, path: options.path, endpoint: endpoint || site?.url });
+        console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json }));
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
   addCommonOptions(cmd.command('test <planfile> [index]').description('Execute tests from a plan file. Index: 1, 1-3, *')).action(async (planfile, index, options) => {
     setPreserveConsoleLogs(true);
     try {

package/boat/doc-collector/src/cli.ts

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { Command } from 'commander';
-import { setPreserveConsoleLogs } from '../../../src/utils/logger.ts';
+import { ConfigCommand } from '../../../src/commands/config-command.ts';
+import { isVerboseMode, setPreserveConsoleLogs, setQuietMode } from '../../../src/utils/logger.ts';
 import { DocBot, type DocbotOptions } from './docbot.ts';
 
 function buildOptions(options: any): DocbotOptions {
@@ -65,6 +66,18 @@ export function createDocsCommands(name = 'docs'): Command {
     }
   });
 
+  addCommonOptions(cmd.command('config [url]').description('Show models, config file and paths used by this run'))
+    .option('--json', 'Print the resolved config as JSON')
+    .action(async (url, options) => {
+      setQuietMode(!isVerboseMode());
+      try {
+        console.log(await ConfigCommand.summary({ config: options.config, path: options.path, url, json: options.json }));
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+
   cmd
     .command('init')
     .description('Initialize doc collector configuration')

package/boat/prima/src/cli.ts

@@ -22,17 +22,27 @@ const helpContract = dedent`
 `;
 
 const checkHelp = dedent`
-  check takes an outcome rather than a click path, and works out how to reach it.
+  check takes an outcome rather than a click path, and works out how to reach it. It runs
+  on the page you are already on and never reloads it, so an open dialog survives the check.
   --expected  one outcome the run must reach, repeatable for several. Without it the
               scenario text is the single expected outcome. Each comes back under
-              ### Expected outcomes as PASSED, FAILED or not verified - "not verified"
-              means the run never checked it, which is not the same as false.
+              ### Expected outcomes as PASSED, FAILED, CONTRADICTION or not verified.
+              "not verified" means the run never checked it, which is not the same
+              as false.
+  Outcomes are settled against a screenshot of the whole page: what a user can see is
+  the proof, and the run log only says what was done. CONTRADICTION means the two
+  disagree - reported with both sides rather than settled one way, and ### Artifacts
+  then names the html, aria and screenshot on disk so you can judge it yourself. Not
+  finding something in the picture is not enough on its own; that is "not verified".
+  ok: follows those outcomes - false when one FAILED or CONTRADICTED, or when the run
+  could not complete, which is reported as such rather than as an app failure.
   Page problems seen on the way appear under ### Answer, not as step failures.
 `;
 
 const doHelp = dedent`
-  Each instruction is numbered and accounted for: ### Steps reports each as ok or FAIL
-  with what proved it. One that could not be carried out fails the command and says why.
+  Each instruction is numbered and accounted for: ### Steps reports each as ok, FAIL or ??.
+  ?? means the action ran but the run ended without confirming that instruction - read the
+  steps above it. Only FAIL and an instruction the page could not carry out fail the command.
   Nothing runs past the last instruction given. A whole remaining sequence in one call is
   what makes this tier cheap.
 `;
@@ -186,13 +196,15 @@ export function createPrimaCommands(name = 'prima'): Command {
     await runPrima(options, `go ${target}`, (prima) => prima.go(target));
   });
 
-  addCommonOptions(cmd.command('config').description('Show the AI models prima runs on and the config file they come from')).action(async (options) => {
-    setQuietMode(!isVerboseMode());
-    const prima = primaFor(options);
-    console.log(await prima.config().catch((error: unknown) => browserErrorMessage(error)));
-    await prima.stop().catch(() => {});
-    process.exit(0);
-  });
+  addCommonOptions(cmd.command('config').description('Show models, config file and paths used by this run'))
+    .option('--json', 'Print the resolved config as JSON')
+    .action(async (options) => {
+      setQuietMode(!isVerboseMode());
+      const prima = primaFor(options);
+      console.log(await prima.config(options.json).catch((error: unknown) => browserErrorMessage(error)));
+      await prima.stop().catch(() => {});
+      process.exit(0);
+    });
 
   addCommonOptions(cmd.command('status <hash>').description('Show the artifacts and page detail recorded for an earlier command')).action(async (hash, options) => {
     await runPrima(options, `status ${hash}`, (prima) => prima.status(hash), false);

package/boat/prima/src/envelope.ts

@@ -2,9 +2,10 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 
 const EXPECTATION_LABELS = {
-  passed: 'PASSED      ',
-  failed: 'FAILED      ',
-  unverified: 'not verified',
+  passed: 'PASSED       ',
+  failed: 'FAILED       ',
+  unverified: 'not verified ',
+  contradiction: 'CONTRADICTION',
 };
 
 export interface InstanceInfo {
@@ -21,8 +22,9 @@ export interface EnvelopeData {
   used?: string[];
   page: { url: string; previousUrl?: string; title: string; state: string; visits: number };
   changes?: string | null;
-  steps?: Array<{ label: string; ok: boolean; proof: string }>;
-  expectations?: Array<{ text: string; status: 'passed' | 'failed' | 'unverified' }>;
+  steps?: Array<{ label: string; ok: boolean; unconfirmed?: boolean; proof: string }>;
+  expectations?: Array<{ text: string; status: 'passed' | 'failed' | 'unverified' | 'contradiction'; evidence?: string }>;
+  warning?: string;
   stepFiles?: string;
   value?: string;
   answer?: string;
@@ -31,23 +33,28 @@ export interface EnvelopeData {
   failure?: { error: string; compactAria?: string };
   instance: InstanceInfo;
   status?: string;
-  artifacts?: { aria: string; html: string; network?: string };
+  artifacts?: { aria: string; html: string; screenshot?: string; network?: string };
 }
 
 export function renderEnvelope(data: EnvelopeData): string {
-  const sections = [renderResult(data), renderPage(data), renderValue(data), renderChanges(data), renderSteps(data), renderExpectations(data), renderOutcome(data), ...renderFailure(data), renderInstance(data), renderArtifacts(data)];
+  const sections = [renderResult(data), renderPage(data), renderValue(data), renderChanges(data), renderSteps(data), renderExpectations(data), renderWarning(data), renderOutcome(data), ...renderFailure(data), renderInstance(data), renderArtifacts(data)];
   return sections.filter((section) => section).join('\n\n');
 }
 
-export function writeArtifacts(dir: string, snapshot: { aria: string | null; html: string | null; requests: unknown[] }): { aria: string; html: string; network?: string } {
+export function writeArtifacts(dir: string, snapshot: { aria: string | null; html: string | null; screenshot?: Buffer; requests: unknown[] }): { aria: string; html: string; screenshot?: string; network?: string } {
   mkdirSync(dir, { recursive: true });
-  const paths: { aria: string; html: string; network?: string } = {
+  const paths: { aria: string; html: string; screenshot?: string; network?: string } = {
     aria: path.resolve(dir, 'aria.yml'),
     html: path.resolve(dir, 'page.html'),
   };
   writeFileSync(paths.aria, snapshot.aria ?? '', 'utf-8');
   writeFileSync(paths.html, snapshot.html ?? '', 'utf-8');
 
+  if (snapshot.screenshot) {
+    paths.screenshot = path.resolve(dir, 'page.png');
+    writeFileSync(paths.screenshot, snapshot.screenshot);
+  }
+
   if (!snapshot.requests.length) return paths;
 
   paths.network = path.resolve(dir, 'network.jsonl');
@@ -87,7 +94,10 @@ function renderSteps(data: EnvelopeData): string | null {
 
   const lines: string[] = [];
   data.steps.forEach((step, index) => {
-    lines.push(`${index + 1}. ${step.ok ? 'ok  ' : 'FAIL'} ${step.label}`);
+    let mark = 'FAIL';
+    if (step.ok) mark = 'ok  ';
+    if (step.unconfirmed) mark = '??  ';
+    lines.push(`${index + 1}. ${mark} ${step.label}`);
     for (const line of (step.proof || '').split('\n').filter(Boolean)) lines.push(`      ${line}`);
   });
   if (data.stepFiles) lines.push('', `page after each step: ${data.stepFiles}`);
@@ -96,10 +106,21 @@ function renderSteps(data: EnvelopeData): string | null {
 
 function renderExpectations(data: EnvelopeData): string | null {
   if (!data.expectations?.length) return null;
-  const lines = data.expectations.map((expectation, index) => `${index + 1}. ${EXPECTATION_LABELS[expectation.status]} ${expectation.text}`);
+
+  const lines: string[] = [];
+  data.expectations.forEach((expectation, index) => {
+    lines.push(`${index + 1}. ${EXPECTATION_LABELS[expectation.status]} ${expectation.text}`);
+    if (expectation.status !== 'contradiction' && expectation.status !== 'failed') return;
+    for (const line of (expectation.evidence || '').split('\n').filter(Boolean)) lines.push(`      ${line}`);
+  });
   return section('Expected outcomes', lines.join('\n'));
 }
 
+function renderWarning(data: EnvelopeData): string | null {
+  if (!data.warning) return null;
+  return section('Warning', data.warning);
+}
+
 function renderOutcome(data: EnvelopeData): string | null {
   if (data.answer) return section('Answer', data.answer);
   if (data.research) return section('Research', data.research);
@@ -154,8 +175,9 @@ function tabsLabel(tabs: number): string {
 
 export function renderArtifacts(data: EnvelopeData): string | null {
   if (!data.artifacts) return null;
-  const lines = [`aria: ${data.artifacts.aria}`, `html: ${data.artifacts.html}`];
-  if (data.artifacts.network) lines.push(`network: ${data.artifacts.network}`);
+  const lines = [`aria:       ${data.artifacts.aria}`, `html:       ${data.artifacts.html}`];
+  if (data.artifacts.screenshot) lines.push(`screenshot: ${data.artifacts.screenshot}`);
+  if (data.artifacts.network) lines.push(`network:    ${data.artifacts.network}`);
   return section('Artifacts', lines.join('\n'));
 }
 

package/boat/prima/src/prima.ts

@@ -4,30 +4,31 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 import { tool } from 'ai';
 import dedent from 'dedent';
-import { z } from 'zod';
 import * as playwright from 'playwright';
 import type { Browser } from 'playwright';
+import { z } from 'zod';
 import { ActionResult } from '../../../src/action-result.ts';
+import { getPreviousResearch } from '../../../src/ai/researcher/cache.ts';
 import { actionRule, locatorRule } from '../../../src/ai/rules.ts';
 import { createAgentTools, createCodeceptJSTools } from '../../../src/ai/tools.ts';
 import { getAliveEndpoint, launchServer, listInstances, stopServer } from '../../../src/browser-server.ts';
-import { listSites } from '../../../src/global-config.ts';
+import { ConfigCommand } from '../../../src/commands/config-command.ts';
 import { ConfigMissingError, ConfigParser, type ExplorbotConfig, outputPath } from '../../../src/config.ts';
 import { ExplorBot } from '../../../src/explorbot.ts';
+import { listSites } from '../../../src/global-config.ts';
 import { Reporter } from '../../../src/reporter.ts';
-import { Stats } from '../../../src/stats.ts';
 import type { WebPageState } from '../../../src/state-manager.ts';
+import { Stats } from '../../../src/stats.ts';
 import { Task, Test, TestResult } from '../../../src/test-plan.ts';
-import { getPreviousResearch } from '../../../src/ai/researcher/cache.ts';
 import { compactAriaSnapshot } from '../../../src/utils/aria.ts';
-import { mdq } from '../../../src/utils/markdown-query.ts';
 import { browserErrorMessage } from '../../../src/utils/browser-errors.ts';
 import { pluralize } from '../../../src/utils/logger.ts';
+import { mdq } from '../../../src/utils/markdown-query.ts';
 import { safeFilename } from '../../../src/utils/strings.ts';
 import { type EnvelopeData, type InstanceInfo, writeArtifacts } from './envelope.ts';
 import { isFunctionExpression, takePwValue, toCodeceptWrapper } from './pw-parser.ts';
-import { type SessionRun, latestSessionFile, readSession, recordCommand, sessionFile, sessionsDir } from './session-log.ts';
 import { type PwServerDescriptor, readDescriptors, selectDescriptor } from './pw-registry.ts';
+import { type SessionRun, latestSessionFile, readSession, recordCommand, sessionFile, sessionsDir } from './session-log.ts';
 
 const TESTER_ONLY_TOOLS = ['learnExperience', 'askUser'];
 const ITERATIONS_PER_INSTRUCTION = 2;
@@ -40,7 +41,7 @@ const CONNECT_TIMEOUT = 3000;
 const requireLib = createRequire(import.meta.url);
 
 const VOLATILE_COLUMNS = ['CSS', 'XPath', 'Coordinates', 'eidx'];
-const UNACCOUNTED: Record<string, string> = { open: 'never reported — the run ended with this instruction still open' };
+const UNACCOUNTED: Record<string, string> = { open: 'the run ended without confirming this one — the actions above are everything that ran' };
 
 function dropVolatileColumns(markdown: string): string {
   return mdq(markdown)
@@ -73,6 +74,7 @@ export class Prima {
   private server: { close: () => Promise<void> } | null = null;
   private attached: string | null = null;
   private session: SessionRun | null = null;
+  private artifacts?: EnvelopeData['artifacts'];
 
   constructor(options: PrimaOptions = {}) {
     this.options = options;
@@ -227,12 +229,12 @@ export class Prima {
 
     if (aiError) return this.failureEnvelope(command, aiError, previousState);
 
-    if (used.length && ledger.some((entry) => entry.status === 'open')) {
+    if (trace.length && ledger.some((entry) => entry.status === 'open')) {
       await this.settleLedger(conversation, provider, ledger, trace);
     }
 
     const unfinished = ledger.filter((entry) => entry.status !== 'done');
-    const steps = [...trace, ...ledger.filter((entry) => entry.status === 'open').map((entry) => ({ label: `unreported: ${entry.text}`, ok: false, proof: UNACCOUNTED.open }))];
+    const steps = [...trace, ...ledger.filter((entry) => entry.status === 'open').map((entry) => ({ label: entry.text, ok: false, unconfirmed: true, proof: UNACCOUNTED.open }))];
 
     if (failure && unfinished.length) {
       const envelope = await this.failureEnvelope(command, failure.message, previousState);
@@ -241,7 +243,7 @@ export class Prima {
       return envelope;
     }
 
-    if (!used.length && unfinished.length === ledger.length) {
+    if (!trace.length && unfinished.length === ledger.length) {
       const reason = ['No action was performed for these instructions on the current page.', narration].filter(Boolean).join(' ');
       return this.failureEnvelope(command, reason, previousState);
     }
@@ -254,10 +256,10 @@ export class Prima {
     envelope.used = undefined;
     envelope.changes = undefined;
 
-    const unmet = unfinished.map((entry) => `${entry.status}: ${entry.text}${entry.proof ? ` — ${entry.proof}` : ''}`);
-    if (unmet.length) {
+    const blocked = ledger.filter((entry) => entry.status === 'blocked');
+    if (blocked.length) {
       envelope.ok = false;
-      envelope.failure = { error: unmet.join('\n') };
+      envelope.failure = { error: blocked.map((entry) => `blocked: ${entry.text}${entry.proof ? ` — ${entry.proof}` : ''}`).join('\n') };
     }
     return envelope;
   }
@@ -309,7 +311,13 @@ export class Prima {
       completed() for those, blocked() for the ones the page could not do. Report every one — nothing else runs after this.
     `);
 
-    const invoked = await provider.invokeConversation(conversation, { completed: this.completedTool(), blocked: this.blockedTool() }, { maxToolRoundtrips: 2, toolChoice: 'required', agentName: AI_AGENT_NAME }).catch(() => null);
+    let settleError: unknown = null;
+    const invoked = await provider.invokeConversation(conversation, { completed: this.completedTool(), blocked: this.blockedTool() }, { maxToolRoundtrips: 2, toolChoice: 'required', agentName: AI_AGENT_NAME }).catch((error: unknown) => {
+      settleError = error;
+      return null;
+    });
+
+    if (settleError) trace.push({ label: 'settling which instructions were satisfied', ok: false, proof: browserErrorMessage(settleError) });
 
     for (const execution of invoked?.toolExecutions || []) {
       this.applyLedgerReport(execution, ledger, trace);
@@ -336,11 +344,11 @@ export class Prima {
     const test = new Test(scenario, 'normal', outcomes, previousState?.url || this.options.url || '');
     const tester = this.bot.agentTester();
 
-    const outcome = await tester.test(test);
+    await tester.test(test, { startOnCurrentPage: true });
 
     const notes = Object.values(test.notes || {}) as Array<{ message: string; status?: string; log?: string; observation?: boolean }>;
-    const result = await this.capturedResult(this.bot.stateManager().getCurrentState());
-    const envelope = await this.reportEnvelope(command, result, previousState, { ok: outcome.success });
+    const result = await this.capturedResult(this.bot.stateManager().getCurrentState(), { screenshot: this.visionEnabled() });
+    const envelope = await this.reportEnvelope(command, result, previousState, {});
     const recorded = notes.filter((note) => !note.observation && !outcomes.includes(note.message));
     const failed = recorded.filter((note) => note.status === TestResult.FAILED);
     envelope.steps = failed.map((note) => ({ label: note.message, ok: false, proof: note.log || '' }));
@@ -348,7 +356,24 @@ export class Prima {
     const routine = recorded.length - failed.length;
     if (routine) envelope.steps.push({ label: `${routine} further ${pluralize(routine, 'step')} ran without failing — prima status ${envelope.status} for the full log`, ok: true, proof: '' });
 
-    envelope.expectations = await this.bot.agentPilot().settleExpectations(test);
+    envelope.expectations = await this.bot.agentPilot().settleExpectations(test, result);
+
+    if (!result.screenshot || !this.visionEnabled()) {
+      envelope.warning = 'These outcomes were settled from the run log alone — no screenshot backed them. Set ai.visionModel, or check anything visual with prima ask.';
+    }
+
+    const unreached = envelope.expectations.filter((expectation) => expectation.status === 'failed');
+    const contradicted = envelope.expectations.filter((expectation) => expectation.status === 'contradiction');
+    envelope.ok = !unreached.length && !contradicted.length;
+
+    const problems = [...unreached.map((expectation) => `not reached: ${expectation.text}`), ...contradicted.map((expectation) => `the picture and the run disagree about: ${expectation.text}`)];
+    if (problems.length) envelope.failure = { error: problems.join('\n') };
+    if (contradicted.length) envelope.artifacts = this.artifacts;
+
+    if (!test.hasFinished || test.isSkipped) {
+      envelope.ok = false;
+      envelope.failure = { error: `the run did not complete, so it established nothing about the app: ${notes.at(-1)?.message || 'no steps were recorded'}` };
+    }
 
     const observations = notes.filter((note) => note.observation).map((note) => note.message);
     if (observations.length) envelope.answer = ['Page problems noticed while running, not step failures:', ...observations.map((line) => `- ${line}`)].join('\n');
@@ -373,7 +398,15 @@ export class Prima {
     const previousState = this.bot.stateManager().getCurrentState();
     const result = await this.capturedResult(previousState);
     const verification = await this.bot.agentNavigator().verifyState(assertion, result);
-    return this.reportEnvelope(command, result, previousState, { assertions: verification.results || [] });
+    const outcome: Partial<EnvelopeData> = { assertions: verification.results || [] };
+
+    if (verification.inexpressible) {
+      const question = `Judging only from the screenshot, is this true of the page: "${assertion}"? Answer true, false or undetermined, and say what settles it.`;
+      const seen = await this.visionAnswer(question, await this.capturedResult(previousState, { screenshot: this.visionEnabled() }));
+      if (seen) outcome.answer = `No assertion could express this claim, so it was judged from a screenshot instead.\n\n${seen}`;
+    }
+
+    return this.reportEnvelope(command, result, previousState, outcome);
   }
 
   async research(opts: { data?: boolean; deep?: boolean; fresh?: boolean } = {}): Promise<EnvelopeData> {
@@ -436,27 +469,13 @@ export class Prima {
     return stopped;
   }
 
-  async config(): Promise<string> {
+  async config(json?: boolean): Promise<string> {
     const [site] = listSites();
     if (site && !this.configBaseUrl()) this.sessionUrl = site.url;
     const config = await this.loadConfig();
+    const parser = ConfigParser.getInstance();
 
-    const named = (model: unknown): string => {
-      if (typeof model === 'string') return model;
-      return (model as any)?.modelId || (model as any)?.model || 'unknown';
-    };
-
-    const ai = config.ai || ({} as any);
-    const roles: Array<[string, unknown]> = [
-      ['model', ai.model],
-      ['agenticModel', ai.agenticModel],
-      ['visionModel', ai.visionModel],
-    ];
-
-    const lines = roles.filter(([, model]) => model).map(([role, model]) => `${role.padEnd(14)} ${named(model)}`);
-    lines.push(`config         ${ConfigParser.getInstance().getConfigPath() || 'built-in defaults'}`);
-    if (ai.langfuse?.enabled) lines.push('telemetry      langfuse');
-    return lines.join('\n');
+    return ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json });
   }
 
   record(envelope: EnvelopeData, durationMs: number): void {
@@ -752,6 +771,7 @@ export class Prima {
       <proof>
       An instruction is done only when a change on the page shows it. After each action read the reported change and decide which part of it proves the instruction.
       That part is what completed() takes as its proof. Do not restate the action as if it were the outcome.
+      How much of the page moved is not evidence of whether it happened — a change confined to one region proves an instruction as well as one that redraws everything.
       An instruction that only inspects the page is satisfied by what you can see, including seeing that something is absent — those need no action at all.
       </proof>
 
@@ -909,6 +929,7 @@ export class Prima {
 
   private visionEnabled(): boolean {
     if (this.options.noVision) return false;
+    if (Stats.visionDisabled) return false;
     return this.bot.getProvider().hasVision?.() === true;
   }
 
@@ -1035,7 +1056,6 @@ export class Prima {
       ok: true,
       command: `status ${hash}`,
       page: saved.page,
-      changes: saved.changes,
       instance: await this.instanceInfo(),
       artifacts: { aria: path.join(dir, 'aria.yml'), html: path.join(dir, 'page.html') },
     };
@@ -1044,7 +1064,7 @@ export class Prima {
   private async saveStatus(result: ActionResult): Promise<string> {
     const hash = this.statusHash();
     await this.writeSnapshot(result);
-    writeFileSync(path.join(this.statusDir(hash), 'status.json'), JSON.stringify({ page: this.pageBlock(result, null), changes: compactAriaSnapshot(result.ariaSnapshot, true) }), 'utf-8');
+    writeFileSync(path.join(this.statusDir(hash), 'status.json'), JSON.stringify({ page: this.pageBlock(result, null) }), 'utf-8');
     return hash;
   }
 
@@ -1062,13 +1082,13 @@ export class Prima {
     if (diff) writeFileSync(`${stem}.diff.yaml`, diff, 'utf-8');
   }
 
-  private async writeSnapshot(result: ActionResult): Promise<undefined> {
-    writeArtifacts(this.statusDir(), {
+  private async writeSnapshot(result: ActionResult): Promise<void> {
+    this.artifacts = writeArtifacts(this.statusDir(), {
       aria: result.ariaSnapshot,
       html: await result.combinedHtml(),
+      screenshot: result.screenshot,
       requests: this.bot.requestStore().getRequests(),
     });
-    return undefined;
   }
 
   private statusHash(): string {

package/dist/bin/explorbot-cli.js

@@ -15,7 +15,7 @@ import { remote } from '../src/remote.js';
 import { Stats } from '../src/stats.js';
 import { Plan } from '../src/test-plan.js';
 import { getCliName } from "../src/utils/cli-name.js";
-import { log, setPreserveConsoleLogs } from '../src/utils/logger.js';
+import { isVerboseMode, log, setPreserveConsoleLogs, setQuietMode } from '../src/utils/logger.js';
 import { jsonToTable } from '../src/utils/markdown-parser.js';
 import { parseMarkdownToTerminal } from '../src/utils/markdown-terminal.js';
 import { printNextSteps, relativeToCwd } from "../src/utils/next-steps.js";
@@ -386,6 +386,23 @@ addCommonOptions(program
     const cmd = new FreesailCommand(explorBot);
     await cmd.execute(args);
 });
+program
+    .command('config [url]')
+    .description('Show models, config file and paths used by this run')
+    .option('-c, --config <path>', 'Path to configuration file')
+    .option('-p, --path <path>', 'Working directory path')
+    .option('--json', 'Print the resolved config as JSON')
+    .action(async (url, options) => {
+    setQuietMode(!isVerboseMode());
+    const { ConfigCommand } = await import('../src/commands/config-command.js');
+    try {
+        console.log(await ConfigCommand.summary({ config: options.config, path: options.path, url, json: options.json }));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+});
 program
     .command('init')
     .description('Initialize configuration for a project or for this machine')
@@ -826,10 +843,5 @@ ${rows}
       ${cli} explore /login --max-tests 3
 `;
 };
-const addEnvHelp = (cmd) => {
-    cmd.addHelpText('after', envHelp);
-    for (const sub of cmd.commands)
-        addEnvHelp(sub);
-};
-addEnvHelp(program);
+program.addHelpText('after', envHelp);
 program.parse();

package/dist/boat/api-tester/src/cli.js

@@ -1,9 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { Command } from 'commander';
+import { ConfigCommand } from "../../../src/commands/config-command.js";
+import { listSites } from "../../../src/global-config.js";
 import { setPreserveConsoleLogs } from "../../../src/utils/logger.js";
 import { getStyles } from "./ai/chief/styles.js";
 import { ApiBot } from "./apibot.js";
+import { ApibotConfigParser } from "./config.js";
 function buildOptions(options) {
     return {
         verbose: options.verbose || options.debug,
@@ -68,6 +71,20 @@ export function createApiCommands(name = 'api') {
             process.exit(1);
         }
     });
+    addCommonOptions(cmd.command('config [endpoint]').description('Show models, config file and paths used by this run'))
+        .option('--json', 'Print the resolved config as JSON')
+        .action(async (endpoint, options) => {
+        const parser = ApibotConfigParser.getInstance();
+        const [site] = listSites();
+        try {
+            const config = await parser.loadConfig({ config: options.config, path: options.path, endpoint: endpoint || site?.url });
+            console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json }));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
     addCommonOptions(cmd.command('test <planfile> [index]').description('Execute tests from a plan file. Index: 1, 1-3, *')).action(async (planfile, index, options) => {
         setPreserveConsoleLogs(true);
         try {

package/dist/boat/doc-collector/src/cli.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { Command } from 'commander';
-import { setPreserveConsoleLogs } from "../../../src/utils/logger.js";
+import { ConfigCommand } from "../../../src/commands/config-command.js";
+import { isVerboseMode, setPreserveConsoleLogs, setQuietMode } from "../../../src/utils/logger.js";
 import { DocBot } from "./docbot.js";
 function buildOptions(options) {
     return {
@@ -56,6 +57,18 @@ export function createDocsCommands(name = 'docs') {
             process.exit(1);
         }
     });
+    addCommonOptions(cmd.command('config [url]').description('Show models, config file and paths used by this run'))
+        .option('--json', 'Print the resolved config as JSON')
+        .action(async (url, options) => {
+        setQuietMode(!isVerboseMode());
+        try {
+            console.log(await ConfigCommand.summary({ config: options.config, path: options.path, url, json: options.json }));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
     cmd
         .command('init')
         .description('Initialize doc collector configuration')