explorbot 0.5.5 → 0.5.7

package/dist/src/commands/freesail-command.js

@@ -4,6 +4,7 @@ import { normalizeUrl } from '../state-manager.js';
 import { Stats } from '../stats.js';
 import { tag } from '../utils/logger.js';
 import { loop } from '../utils/loop.js';
+import { UrlFilter } from "../utils/url-filter.js";
 import { BaseCommand } from './base-command.js';
 import { DEADLINE_RESERVE_MS, DEADLINE_TEST_ALLOWANCE_MS, ExploreCommand } from './explore-command.js';
 export class FreesailCommand extends BaseCommand {
@@ -17,6 +18,7 @@ export class FreesailCommand extends BaseCommand {
         { flags: '--scope <url>', description: 'Limit navigation to URLs starting with this prefix' },
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
         { flags: '--max-duration <number>', description: 'Wall-clock budget in minutes for the whole run' },
+        { flags: '--url-filter <spec>', description: 'Pick pages to explore: keys filter|exclude|limit, e.g. "filter:/admin/*;exclude:/admin/logs/*;limit:20"' },
     ];
     async execute(args) {
         Stats.mode = 'freesail';
@@ -27,6 +29,7 @@ export class FreesailCommand extends BaseCommand {
         if (opts.shallow)
             strategy = 'shallow';
         const scope = opts.scope;
+        const urlFilter = new UrlFilter(opts.urlFilter);
         const maxTests = opts.maxTests ? Number.parseInt(opts.maxTests, 10) : undefined;
         const maxDuration = opts.maxDuration ? Number.parseInt(opts.maxDuration, 10) : undefined;
         let hardDeadlineAt;
@@ -54,6 +57,7 @@ export class FreesailCommand extends BaseCommand {
                     exploreCmd.maxTests = maxTests - testsRun;
                 if (hardDeadlineAt != null)
                     exploreCmd.hardDeadlineAt = hardDeadlineAt;
+                exploreCmd.urlFilter = urlFilter;
                 await exploreCmd.execute('');
                 const plan = this.explorBot.getCurrentPlan();
                 if (plan)
@@ -63,7 +67,7 @@ export class FreesailCommand extends BaseCommand {
                 ctx.stop();
             const navigator = this.explorBot.agentNavigator();
             const visitedUrls = stateManager.getAllVisitedUrls();
-            const suggestion = await navigator.freeSail({ strategy, scope, visitedUrls });
+            const suggestion = await navigator.freeSail({ strategy, scope, visitedUrls, urlFilter });
             if (!suggestion) {
                 tag('info').log('No navigation suggestion available');
                 ctx.stop();
@@ -72,6 +76,10 @@ export class FreesailCommand extends BaseCommand {
                 tag('warning').log(`Suggestion ${suggestion.target} is outside scope ${scope}, skipping`);
                 ctx.stop();
             }
+            if (!urlFilter.admit(suggestion.target)) {
+                tag('info').log(`URL filter allows no more pages (${suggestion.target} not admitted); stopping exploration`);
+                ctx.stop();
+            }
             const currentUrl = stateManager.getCurrentState()?.url;
             if (currentUrl && normalizeUrl(suggestion.target) === normalizeUrl(currentUrl)) {
                 tag('info').log(`No new navigation target available after ${currentUrl}; stopping exploration`);

package/dist/src/commands/init-command.js

@@ -225,7 +225,10 @@ export function modelLines(provider, only) {
     let selected = roles;
     if (only)
         selected = roles.filter(([role]) => only.includes(role));
-    return selected.map(([role, comment]) => `    // ${comment}\n    ${role}: '${provider}/${recommended[role] || '<model-id>'}',`).join('\n');
+    const lines = selected.map(([role, comment]) => `    // ${comment}\n    ${role}: '${provider}/${recommended[role] || '<model-id>'}',`);
+    if (!only && recommended.decisionModel)
+        lines.push(`    // decision model judging ambiguous outcomes\n    decisionModel: { provider: '${provider}', model: '${recommended.decisionModel}' },`);
+    return lines.join('\n');
 }
 function globalConfigTemplate(provider) {
     const { envKey } = PROVIDERS[provider];

package/dist/src/commands/recommended-models-command.js

@@ -44,6 +44,8 @@ export class RecommendedModelsCommand extends BaseCommand {
                 if (!roles[role])
                     models.push([label, chalk.dim('not served, pair with another provider')]);
             }
+            if (roles.decisionModel)
+                models.push(['decisionModel (judge)', roles.decisionModel]);
             lines.push(...renderSection('models', models, 2));
             const envKey = PROVIDERS[provider]?.envKey;
             if (!envKey) {
@@ -61,6 +63,8 @@ export class RecommendedModelsCommand extends BaseCommand {
                 env.push([label, `${ROLES[role].env}=${provider}/${roles[role]}`]);
                 label = '';
             }
+            if (roles.decisionModel)
+                env.push(['decision', `EXPLORBOT_DECISION_MODEL=${provider}/${roles.decisionModel}`]);
             lines.push(...renderSection('env variables', env, 2));
         }
         const modelVars = ['EXPLORBOT_AI_PROVIDER', ...MODEL_ENV_VARS];

package/dist/src/config.js

@@ -137,6 +137,10 @@ export class ConfigParser {
                 sourcePath = join(outputRoot, 'explorbot.config.js');
                 log(`Configuration built from EXPLORBOT_* environment variables. Output: ${outputRoot}`);
             }
+            const configuredUrl = loadedConfig?.playwright?.url || loadedConfig?.web?.url || '';
+            if (!this.runBase && resolvedPath && !isGlobalConfigPath(resolvedPath) && URL.canParse(configuredUrl)) {
+                this.runBase = parseRunBase(configuredUrl);
+            }
             let config = this.resolveConfig(loadedConfig);
             await resolveConfigModels(config.ai);
             this.site = null;
@@ -377,6 +381,8 @@ export class ConfigParser {
             ai.agenticModel = await resolveModel(agenticSpec, 'agenticModel');
         if (!agenticSpec && recommended.agenticModel)
             ai.agenticModel = await resolveModel(provider, 'agenticModel');
+        if (recommended.decisionModel)
+            ai.decisionModel = { provider: provider, model: recommended.decisionModel };
         const dirs = { knowledge: 'knowledge', experience: 'experience', output: 'output' };
         if (process.env.EXPLORBOT_OUTPUT)
             dirs.output = '.';

package/dist/src/test-plan.d.ts

@@ -121,6 +121,7 @@ export declare class Test extends Task {
     get isSkipped(): boolean;
     getCheckedNotes(): Note[];
     getCheckedExpectations(): string[];
+    hasAchieved(expectation: string): boolean;
     hasAchievedAny(): boolean;
     getRunResult(): 'success' | 'partial' | 'failed';
     hasAchievedAll(): boolean;

package/dist/src/test-plan.js

@@ -272,10 +272,11 @@ export class Test extends Task {
             return Object.values(this.notes).some((note) => note.message === expectation && !!note.status);
         });
     }
+    hasAchieved(expectation) {
+        return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);
+    }
     hasAchievedAny() {
-        return this.expected.some((expectation) => {
-            return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);
-        });
+        return this.expected.some((expectation) => this.hasAchieved(expectation));
     }
     getRunResult() {
         if (this.isSuccessful)
@@ -285,9 +286,7 @@ export class Test extends Task {
         return super.getRunResult();
     }
     hasAchievedAll() {
-        return this.expected.every((expectation) => {
-            return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);
-        });
+        return this.expected.every((expectation) => this.hasAchieved(expectation));
     }
     isComplete() {
         return this.expected.every((expectation) => {

package/dist/src/utils/sitemap.d.ts

@@ -0,0 +1,11 @@
+import type { UrlFilter } from './url-filter.js';
+export declare function readSitemap(source: string, filter?: UrlFilter): Promise<string[]>;
+export declare function readCliSitemap(path: string | undefined, source: string | undefined, filter?: UrlFilter): Promise<string[] | undefined>;
+export declare function keepSiteUrls(urls: string[], siteUrl: string): string[];
+export declare function extractEntries(content: string): SitemapEntry[];
+interface SitemapEntry {
+    url: string;
+    priority: number;
+    lastmod?: number;
+}
+export {};

package/dist/src/utils/sitemap.js

@@ -0,0 +1,106 @@
+import { readFileSync } from 'node:fs';
+import { tag } from './logger.js';
+const ENTRY_PATTERN = /<(url|sitemap)\b[^>]*>(.*?)<\/\1>/gis;
+const XML_ENTITIES = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" };
+const MAX_NESTED_SITEMAPS = 50;
+const DEFAULT_PRIORITY = 0.5;
+const STDIN_SOURCE = '-';
+export async function readSitemap(source, filter) {
+    const entries = [];
+    const seen = new Set();
+    const pending = [source];
+    let fetched = 0;
+    while (pending.length > 0) {
+        if (fetched >= MAX_NESTED_SITEMAPS) {
+            tag('warning').log(`Sitemap index lists more than ${MAX_NESTED_SITEMAPS} sitemaps, the rest are ignored`);
+            break;
+        }
+        const next = pending.shift();
+        fetched++;
+        const content = await readSource(next);
+        const isIndex = content.includes('<sitemapindex');
+        for (const entry of extractEntries(content)) {
+            if (seen.has(entry.url))
+                continue;
+            seen.add(entry.url);
+            if (isIndex) {
+                pending.push(entry.url);
+                continue;
+            }
+            entries.push(entry);
+        }
+    }
+    return applyFilter(entries, filter).map((entry) => entry.url);
+}
+export async function readCliSitemap(path, source, filter) {
+    const usage = 'Pass a page path, --sitemap <source>, or pipe a sitemap to stdin';
+    let resolved = source;
+    if (!resolved && !path && !process.stdin.isTTY)
+        resolved = STDIN_SOURCE;
+    if (!resolved && !path)
+        throw new Error(usage);
+    if (!resolved)
+        return undefined;
+    const urls = await readSitemap(resolved, filter);
+    if (urls.length === 0 && !source)
+        throw new Error(usage);
+    if (urls.length === 0)
+        throw new Error(`No URLs left in sitemap ${resolved}`);
+    return urls;
+}
+export function keepSiteUrls(urls, siteUrl) {
+    const siteOrigin = URL.parse(siteUrl)?.origin;
+    const kept = urls.filter((url) => url.startsWith('/') || URL.parse(url)?.origin === siteOrigin);
+    if (kept.length < urls.length)
+        tag('warning').log(`Skipped ${urls.length - kept.length} sitemap URL(s) outside ${siteOrigin}`);
+    return kept;
+}
+export function extractEntries(content) {
+    if (!content.trimStart().startsWith('<')) {
+        return content
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.startsWith('http://') || line.startsWith('https://') || line.startsWith('/'))
+            .map((url) => ({ url, priority: DEFAULT_PRIORITY }));
+    }
+    const entries = [];
+    for (const match of content.matchAll(ENTRY_PATTERN)) {
+        const url = tagValue(match[2], 'loc');
+        if (!url)
+            continue;
+        const entry = { url, priority: DEFAULT_PRIORITY };
+        const priority = Number.parseFloat(tagValue(match[2], 'priority') || '');
+        if (!Number.isNaN(priority))
+            entry.priority = priority;
+        const lastmod = Date.parse(tagValue(match[2], 'lastmod') || '');
+        if (!Number.isNaN(lastmod))
+            entry.lastmod = lastmod;
+        entries.push(entry);
+    }
+    return entries;
+}
+function applyFilter(entries, filter) {
+    if (!filter)
+        return entries;
+    let result = entries.filter((entry) => filter.allows(entry.url));
+    if (filter.sort === 'priority')
+        result = result.toSorted((a, b) => b.priority - a.priority);
+    if (filter.sort === 'lastmod')
+        result = result.toSorted((a, b) => (b.lastmod ?? 0) - (a.lastmod ?? 0));
+    return result.slice(0, filter.limit);
+}
+function tagValue(block, name) {
+    const match = block.match(new RegExp(`<${name}>\\s*(?:<!\\[CDATA\\[)?\\s*(.*?)\\s*(?:\\]\\]>)?\\s*</${name}>`, 'is'));
+    return match?.[1].replace(/&(amp|lt|gt|quot|apos);/g, (entity) => XML_ENTITIES[entity]) || undefined;
+}
+async function readSource(source) {
+    if (source === STDIN_SOURCE)
+        return readFileSync(0, 'utf8');
+    if (source.startsWith('http://') || source.startsWith('https://')) {
+        const response = await fetch(source);
+        if (!response.ok)
+            throw new Error(`Sitemap ${source} returned HTTP ${response.status}`);
+        return await response.text();
+    }
+    return readFileSync(source, 'utf8');
+}

package/dist/src/utils/spec.d.ts

@@ -0,0 +1,5 @@
+export declare function parseSpecPairs(raw: string | undefined): SpecPair[];
+export interface SpecPair {
+    key: string;
+    value: string;
+}

package/dist/src/utils/spec.js

@@ -0,0 +1,16 @@
+import { tag } from './logger.js';
+export function parseSpecPairs(raw) {
+    const pairs = [];
+    for (const pair of (raw || '').split(';')) {
+        const trimmed = pair.trim();
+        if (!trimmed)
+            continue;
+        const sepMatch = trimmed.match(/^([^:=]+)\s*[:=]\s*(.*)$/);
+        if (!sepMatch) {
+            tag('warning').log(`Ignoring malformed spec pair: ${trimmed}`);
+            continue;
+        }
+        pairs.push({ key: sepMatch[1].trim().toLowerCase(), value: sepMatch[2].trim() });
+    }
+    return pairs;
+}

package/dist/src/utils/url-filter.d.ts

@@ -0,0 +1,10 @@
+export declare class UrlFilter {
+    readonly include: string[];
+    readonly exclude: string[];
+    sort?: 'priority' | 'lastmod';
+    limit: number;
+    admitted: Set<string>;
+    constructor(spec?: string);
+    allows(url: string): boolean;
+    admit(url: string): boolean;
+}

package/dist/src/utils/url-filter.js

@@ -0,0 +1,52 @@
+import { tag } from './logger.js';
+import { parseSpecPairs } from "./spec.js";
+import { matchesUrl } from "./url-matcher.js";
+export class UrlFilter {
+    include = [];
+    exclude = [];
+    sort;
+    limit = Number.POSITIVE_INFINITY;
+    admitted = new Set();
+    constructor(spec) {
+        for (const { key, value } of parseSpecPairs(spec)) {
+            if (key === 'filter') {
+                this.include.push(value);
+                continue;
+            }
+            if (key === 'exclude') {
+                this.exclude.push(value);
+                continue;
+            }
+            if (key === 'sort' && (value === 'priority' || value === 'lastmod')) {
+                this.sort = value;
+                continue;
+            }
+            if (key === 'limit' && Number.parseInt(value, 10) > 0) {
+                this.limit = Number.parseInt(value, 10);
+                continue;
+            }
+            tag('warning').log(`Ignoring URL filter pair ${key}:${value} (use filter|exclude:<url pattern>, sort:priority|lastmod, limit:<n>)`);
+        }
+    }
+    allows(url) {
+        const path = urlPath(url);
+        if (this.include.length > 0 && !this.include.some((pattern) => matchesUrl(pattern, path)))
+            return false;
+        return !this.exclude.some((pattern) => matchesUrl(pattern, path));
+    }
+    admit(url) {
+        if (!this.allows(url))
+            return false;
+        const path = urlPath(url);
+        if (this.admitted.has(path))
+            return true;
+        if (this.admitted.size >= this.limit)
+            return false;
+        this.admitted.add(path);
+        return true;
+    }
+}
+function urlPath(url) {
+    const parsed = new URL(url, 'http://localhost');
+    return `${parsed.pathname}${parsed.search}`;
+}

package/docs/basics/getting-started.md

@@ -39,7 +39,8 @@ export default {
   ai: {
     model: 'openrouter/openai/gpt-oss-20b:nitro',
     visionModel: 'openrouter/openai/gpt-5.6-luna',
-    agenticModel: 'openrouter/openai/gpt-5.6-luna',
+    agenticModel: 'openrouter/anthropic/claude-haiku-5.5',
+    decisionModel: { provider: 'openrouter', model: 'typesafe/jev-latest' },
   },
 };
 ```

package/docs/basics/providers.md

@@ -56,7 +56,8 @@ export default {
   ai: {
     model: openrouter('openai/gpt-oss-20b:nitro'),
     visionModel: openrouter('openai/gpt-5.6-luna'),
-    agenticModel: openrouter('openai/gpt-5.6-luna'),
+    agenticModel: openrouter('anthropic/claude-haiku-5.5'),
+    decisionModel: { provider: 'openrouter', model: 'typesafe/jev-latest' },
   },
 };
 ```
@@ -123,8 +124,8 @@ Set the recommended models in the exported config:
 export default {
   ai: {
     model: openai('gpt-5-nano'),
-    visionModel: openai('gpt-5.6-luna'),
-    agenticModel: openai('gpt-5.6-luna'),
+    visionModel: openai('gpt-6-luna'),
+    agenticModel: openai('gpt-6-luna'),
   },
 };
 ```
@@ -156,9 +157,9 @@ Set the recommended model in the exported config:
 ```javascript
 export default {
   ai: {
-    model: anthropic('claude-haiku-4-5-20251001'),
-    visionModel: anthropic('claude-haiku-4-5-20251001'),
-    agenticModel: anthropic('claude-haiku-4-5-20251001'),
+    model: anthropic('claude-haiku-5-5'),
+    visionModel: anthropic('claude-haiku-5-5'),
+    agenticModel: anthropic('claude-haiku-5-5'),
   },
 };
 ```

package/docs/workflow/agentic-usage.md

@@ -103,7 +103,7 @@ On its own, without a provider, `EXPLORBOT_AI_MODEL` must carry the provider as
 ```
 openrouter/openai/gpt-oss-120b:nitro   → openrouter, model "openai/gpt-oss-120b:nitro"
 groq/openai/gpt-oss-20b                → groq, model "openai/gpt-oss-20b"
-anthropic/claude-haiku-4-5-20251001    → anthropic, model "claude-haiku-4-5-20251001"
+anthropic/claude-haiku-5-5             → anthropic, model "claude-haiku-5-5"
 ```
 
 `EXPLORBOT_VISION_MODEL` and `EXPLORBOT_AGENTIC_MODEL` override those roles the same way — a provider name for its recommendation, or `provider/model-id` to pin one. Mix the forms to take a provider's recommendations and override one role:

package/models.json

@@ -2,7 +2,8 @@
   "openrouter": {
     "model": "openai/gpt-oss-20b:nitro",
     "visionModel": "openai/gpt-5.6-luna",
-    "agenticModel": "openai/gpt-5.6-luna"
+    "agenticModel": "anthropic/claude-haiku-5.5",
+    "decisionModel": "typesafe/jev-latest"
   },
   "poolside": {
     "model": "poolside/laguna-xs-2.1"
@@ -14,13 +15,13 @@
   },
   "openai": {
     "model": "gpt-5-nano",
-    "visionModel": "gpt-5.6-luna",
-    "agenticModel": "gpt-5.6-luna"
+    "visionModel": "gpt-6-luna",
+    "agenticModel": "gpt-6-luna"
   },
   "anthropic": {
-    "model": "claude-haiku-4-5-20251001",
-    "visionModel": "claude-haiku-4-5-20251001",
-    "agenticModel": "claude-haiku-4-5-20251001"
+    "model": "claude-haiku-5-5",
+    "visionModel": "claude-haiku-5-5",
+    "agenticModel": "claude-haiku-5-5"
   },
   "mistral": {
     "model": "mistral-small-latest",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/src/ai/navigator.ts

@@ -20,6 +20,7 @@ import { loop, pause } from '../utils/loop.js';
 import { RulesLoader } from '../utils/rules-loader.ts';
 import { normalizeInlineText } from '../utils/strings.ts';
 import { extractStatePath, isSameHostFamily, matchesNavigationUrl } from '../utils/url-matcher.js';
+import type { UrlFilter } from '../utils/url-filter.ts';
 import type { Agent, AgentDeps } from './agent.js';
 import type { Conversation } from './conversation.js';
 import { type Decision, JUDGE_PAGE_CAP, type Judge, UNDECIDED } from './judge.ts';
@@ -564,7 +565,7 @@ class Navigator implements Agent {
     return { learnExperience: createLearnExperienceTool({ getExperienceTracker: () => this.experienceTracker, getState }) };
   }
 
-  async freeSail(opts?: { strategy?: 'deep' | 'shallow'; scope?: string; visitedUrls?: Set<string> }, actionResult?: ActionResult): Promise<{ target: string; reason: string } | null> {
+  async freeSail(opts?: { strategy?: 'deep' | 'shallow'; scope?: string; visitedUrls?: Set<string>; urlFilter?: UrlFilter }, actionResult?: ActionResult): Promise<{ target: string; reason: string } | null> {
     const stateManager = this.stateManager;
     const state = stateManager.getCurrentState();
     if (!state) {
@@ -612,6 +613,12 @@ class Navigator implements Agent {
     if (opts?.scope) {
       scopeInstruction = `IMPORTANT: Only suggest URLs that start with "${opts.scope}". Do not suggest URLs outside this scope.`;
     }
+    if (opts?.urlFilter?.include.length) {
+      scopeInstruction += `\nOnly suggest URLs matching one of these patterns: ${opts.urlFilter.include.join(', ')}`;
+    }
+    if (opts?.urlFilter?.exclude.length) {
+      scopeInstruction += `\nNever suggest URLs matching these patterns: ${opts.urlFilter.exclude.join(', ')}`;
+    }
 
     const prompt = dedent`
       <research>
@@ -665,6 +672,11 @@ class Navigator implements Agent {
           return;
         }
 
+        if (opts?.urlFilter && !opts.urlFilter.allows(target)) {
+          conversation.addUserText(`"${target}" does not pass the URL filter. Suggest a URL that does.`);
+          return;
+        }
+
         if (!target.startsWith('/') && !target.startsWith('http')) {
           conversation.addUserText(`"${target}" is not a valid URL path. Suggest a URL path starting with "/".`);
           return;

package/src/ai/pilot.ts

@@ -615,7 +615,7 @@ export class Pilot implements Agent {
     if (finalState?.screenshot && this.provider.hasVision()) image = finalState.screenshot;
 
     const decided = (text: string): 'passed' | 'failed' => {
-      if (task.hasAchievedAny() && !task.getRemainingExpectations().includes(text)) return 'passed';
+      if (task.hasAchieved(text)) return 'passed';
       return 'failed';
     };
 
@@ -631,7 +631,7 @@ export class Pilot implements Agent {
       outcomes: z.array(
         z.object({
           expectation: z.string().describe('The expected outcome, repeated exactly as it was given'),
-          status: z.enum(['passed', 'failed', 'unverified', 'contradiction']).describe('passed = the evidence shows it happened, failed = the evidence shows it did not, unverified = the run never established either way, contradiction = the picture and the run disagree'),
+          status: z.enum(['passed', 'failed', 'unverified', 'contradiction']).describe('passed = the evidence shows it happened to the thing it names, failed = the evidence shows it did not, unverified = the run never established either way, contradiction = the picture and the run disagree'),
           evidence: z.string().nullable().describe('What settled it. For a contradiction, what each side shows. Null when there is nothing to add'),
         })
       ),
@@ -657,6 +657,10 @@ export class Pilot implements Agent {
     const userContent = dedent`
       A test run has finished. Decide, for each expected outcome, what the run established about it.
 
+      <scenario>
+      ${task.scenario}
+      </scenario>
+
       <expected_outcomes>
       ${undecided.map((text) => `- ${text}`).join('\n')}
       </expected_outcomes>
@@ -669,6 +673,9 @@ export class Pilot implements Agent {
 
       The log is written in the tester's own words, so an outcome can be satisfied by a step that describes it
       differently. Judge by what the steps show happened, not by whether the wording matches.
+      Wording may differ, the subject may not. An outcome refers to what the scenario names or chooses; it holds
+      only when that same thing appears. A different route or a different thing reaching a similar state is "failed",
+      and so is an outcome about something the run never managed to choose or create.
       Choose "unverified" only when the evidence neither shows the outcome happening nor shows it failing —
       that is a statement about the run, not about the application.
     `;