e2e 0.15.1 → 0.16.0

package/README.md

@@ -1,4 +1,4 @@
-<a href="https://tester.army/e2e?utm_source=e2e&utm_medium=github&utm_campaign=readme_banner"><img src="https://raw.githubusercontent.com/tester-army/e2e/main/.github/assets/readme-banner.png" alt="e2e by TesterArmy" width="100%" /></a>
+<a href="https://tester.army/e2e?utm_source=e2e&utm_medium=github&utm_campaign=readme_banner"><img src="https://raw.githubusercontent.com/tester-army/e2e/main/.github/assets/readme-banner.png" alt="e2e, the open source AI testing framework by TesterArmy" width="100%" /></a>
 
 <p align="center">
   <a href="https://tester.army?utm_source=e2e&utm_medium=github&utm_campaign=readme_badge"><img alt="Made by TesterArmy" src="https://raw.githubusercontent.com/tester-army/e2e/main/.github/assets/made-by-testerarmy.svg" /></a>
@@ -9,8 +9,7 @@
 
 # e2e
 
-[e2e](https://tester.army/e2e?utm_source=e2e&utm_medium=github&utm_campaign=readme_intro) is an end-to-end testing framework for web and mobile apps. Describe a goal in natural language and an agent interacts with the app to complete it. Use locators and assertions in the same test to check exact results. Customize anything from agent to the engine.
-
+[e2e](https://tester.army/e2e?utm_source=e2e&utm_medium=github&utm_campaign=readme_intro) is an end-to-end testing framework for web and mobile apps. Describe a goal in natural language and an agent drives the app to reach it. Check the result with locators and assertions in the same test.
 
 ```ts
 // tests/checkout.e2e.ts
@@ -26,37 +25,65 @@ test('a member upgrades to Pro', async ({ app, agent, screen }) => {
 });
 ```
 
-```bash
-npx e2e init
-```
-
 An agent step that a later assertion verifies records its actions, and the
 next run replays them with no model calls until the app changes. Tests
 without agent steps need no model. Bring your own subscription, API key, or
 local model.
 
-## Documentation
+## Quick start
 
-[e2e.tester.army/docs](https://e2e.tester.army/docs): quickstart, writing
-tests, mobile, migrating from Playwright, Cypress, Selenium, Detox, or
-Maestro, and the full reference.
+```bash
+npx e2e init
+```
+
+`init` asks for an engine, web or mobile, and a model provider, then writes a
+config and an example test. The
+[quickstart](https://e2e.tester.army/docs/quickstart) covers the rest.
 
 ## Packages
 
-- [`e2e`](https://www.npmjs.com/package/e2e): SDK, runner, and CLI.
-- [`@e2e-dev/web`](https://www.npmjs.com/package/@e2e-dev/web): the browser engine.
-- [`@e2e-dev/mobile`](https://www.npmjs.com/package/@e2e-dev/mobile): the iOS and Android engine.
-- [`@e2e-dev/github`](https://www.npmjs.com/package/@e2e-dev/github): the pull request comment reporter.
-- [`@e2e-dev/kernel`](https://www.npmjs.com/package/@e2e-dev/kernel): Kernel hosted browsers for the web
-  engine.
-- [`@e2e-dev/eas`](https://www.npmjs.com/package/@e2e-dev/eas): EAS Simulators hosted iOS simulators and
-  Android emulators for the mobile engine.
+| Package | What it does |
+| --- | --- |
+| [`e2e`](https://www.npmjs.com/package/e2e) | The SDK, runner, and CLI. |
+| [`@e2e-dev/web`](https://www.npmjs.com/package/@e2e-dev/web) | Browser engine: Chromium, Firefox, and WebKit through Playwright. |
+| [`@e2e-dev/mobile`](https://www.npmjs.com/package/@e2e-dev/mobile) | iOS and Android engine: simulators and emulators through agent-device. |
+| [`@e2e-dev/github`](https://www.npmjs.com/package/@e2e-dev/github) | Reporter that posts results as a pull request comment. |
+| [`@e2e-dev/kernel`](https://www.npmjs.com/package/@e2e-dev/kernel) | Kernel hosted browsers for the web engine. |
+| [`@e2e-dev/eas`](https://www.npmjs.com/package/@e2e-dev/eas) | EAS Simulators hosted iOS simulators and Android emulators for the mobile engine. |
+
+## Documentation
+
+[e2e.tester.army/docs](https://e2e.tester.army/docs). The `e2e` package ships
+every page, so coding agents can read them offline in `node_modules/e2e/docs`.
 
 ## Contributing
 
-See [CONTRIBUTING.md](https://github.com/tester-army/e2e/blob/main/CONTRIBUTING.md) and [SECURITY.md](https://github.com/tester-army/e2e/blob/main/SECURITY.md).
-Apache-2.0.
+See [CONTRIBUTING.md](https://github.com/tester-army/e2e/blob/main/CONTRIBUTING.md). Questions go to
+[Discord](https://tester.army/discord).
+
+## Security
+
+Please don't open public issues for security vulnerabilities. Follow
+[SECURITY.md](https://github.com/tester-army/e2e/blob/main/SECURITY.md) and report them to
+[security@tester.army](mailto:security@tester.army).
+
+## Telemetry
+
+The CLI sends anonymous usage data, such as which commands and engines run and
+where runs fail, but no test content, app content, or credentials. Opt out with
+`npx e2e telemetry disable` or `E2E_TELEMETRY_DISABLED=1`.
+[Telemetry](https://e2e.tester.army/docs/telemetry) lists every field.
 
-Built by [TesterArmy](https://tester.army/?utm_source=e2e&utm_medium=github&utm_campaign=readme_footer),
-the agentic testing platform that runs plain-English tests on web and mobile
-apps and reports back with screenshots and recordings.
+## Status
+
+> [!NOTE]
+> e2e is in active development on the way to 1.0. APIs and config can still
+> change between minor releases.
+
+## Made by TesterArmy
+
+e2e is built by [TesterArmy](https://tester.army/?utm_source=e2e&utm_medium=github&utm_campaign=readme_footer),
+the agentic testing platform that runs natural language tests on web and mobile
+apps, on every pull request or on a schedule.
+
+Apache-2.0.

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.15.1"}
+{"version":"0.16.0"}

package/dist/agent/act-validation.d.ts

@@ -35,6 +35,15 @@ export declare function validateParams(params: AgentParams | undefined): {
     secrets: ReadonlyMap<string, Secret>;
     templates: readonly ParamTemplate[];
 };
+/**
+ * Projected params with `redact` applied to every string in them, object
+ * keys included, and their `unique()` templates moved with their leaves: a
+ * template's pointer follows the redacted keys and its value is redacted as
+ * the leaf is, so the trace cache slots what the params hold.
+ */
+export declare function redactParams(params: Readonly<Record<string, JsonValue>>, templates: readonly ParamTemplate[], redact: (text: string) => string): {
+    params: Readonly<Record<string, JsonValue>>;
+    templates: readonly ParamTemplate[];
+};
 /** Closes the verdict grammar: the executor cannot invent statuses or codes. */
 export declare function validateVerdict(verdict: unknown, executorName: string): StepVerdict;
-//# sourceMappingURL=act-validation.d.ts.map

package/dist/agent/act-validation.js

@@ -90,6 +90,54 @@ export function validateParams(params) {
         templates: found.templates,
     };
 }
+/**
+ * Projected params with `redact` applied to every string in them, object
+ * keys included, and their `unique()` templates moved with their leaves: a
+ * template's pointer follows the redacted keys and its value is redacted as
+ * the leaf is, so the trace cache slots what the params hold.
+ */
+export function redactParams(params, templates, redact) {
+    const pointers = new Map();
+    const redacted = redactJson(params, redact, { from: '', to: '' }, pointers);
+    return {
+        params: redacted,
+        templates: templates.map((template) => ({
+            pointer: pointers.get(template.pointer) ?? template.pointer,
+            value: redact(template.value),
+        })),
+    };
+}
+/**
+ * `value` with `redact` applied to every string in it, object keys included.
+ * Records in `pointers` where each node's pointer (`at.from`) lands once its
+ * keys are redacted (`at.to`). Two keys of one object that redact alike would
+ * leave one value standing for both, so that is `INVALID_ARGUMENT`.
+ */
+function redactJson(value, redact, at, pointers) {
+    pointers.set(at.from, at.to);
+    if (typeof value === 'string')
+        return redact(value);
+    if (Array.isArray(value)) {
+        return value.map((entry, index) => redactJson(entry, redact, { from: paramPointer(at.from, index), to: paramPointer(at.to, index) }, pointers));
+    }
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const clean = redact(key);
+        if (Object.hasOwn(out, clean)) {
+            throw new TestError('INVALID_ARGUMENT', `agent.act params has two keys that read ${JSON.stringify(clean)} once secret values are redacted; a key cannot be told apart by a secret`);
+        }
+        // Defined, not assigned, so a `__proto__` key stays an own property.
+        Object.defineProperty(out, clean, {
+            value: redactJson(entry, redact, { from: paramPointer(at.from, key), to: paramPointer(at.to, clean) }, pointers),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return out;
+}
 /** Replaces every Secret leaf with its placeholder and every Unique leaf with its value, collecting both. */
 function projectParams(value, pointer, found, seen) {
     if (isSecret(value)) {
@@ -146,4 +194,3 @@ export function validateVerdict(verdict, executorName) {
         ...(code === undefined ? {} : { errorCode: code }),
     };
 }
-//# sourceMappingURL=act-validation.js.map

package/dist/agent/act.d.ts

@@ -66,5 +66,4 @@ export declare function runAssertStep(runtime: AgentContext, assertion: string,
  * passing is what confirms the traces staged before it at attempt end
  * (cache/context.ts).
  */
-export declare function dispatchAgentStep(runtime: AgentContext, spec: DispatchSpec, agent?: DispatchAgent): Promise<ActResult>;
-//# sourceMappingURL=act.d.ts.map
+export declare function dispatchAgentStep(runtime: AgentContext, raw: DispatchSpec, agent?: DispatchAgent): Promise<ActResult>;

package/dist/agent/act.js

@@ -20,8 +20,8 @@ import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ConfigurationError } from '../internal/errors.js';
 import { withAbort, withTimeout } from '../internal/time.js';
-import { AgentError, CATEGORY_BY_CODE, isAgentError, toAgentError } from './error.js';
-import { validateActOptions, validateInstruction, validateParams, validateVerdict } from './act-validation.js';
+import { AgentError, CATEGORY_BY_CODE, toAgentError } from './error.js';
+import { redactParams, validateActOptions, validateInstruction, validateParams, validateVerdict } from './act-validation.js';
 import { ActionDispatcher } from './action-dispatcher.js';
 import { resolveBoundedBudget, resolveTimeout } from './call-options.js';
 import { RUNTIME_CODES } from './executor.js';
@@ -31,7 +31,7 @@ import { ObservationFeed } from './observation-feed.js';
 import { recordPolicyEvent } from './phases.js';
 import { OperationQueue } from './operation-queue.js';
 import { StepAccounting } from './step-accounting.js';
-import { StepTraceSession } from './step-cache.js';
+import { failedStepOutcome, StepTraceSession } from './step-cache.js';
 /** Runs one `agent.act()` call as a harness-dispatched executor step. */
 export async function runActStep(runtime, instruction, options, extraArguments = 0) {
     const normalized = validateInstruction(instruction, 'agent.act');
@@ -88,12 +88,16 @@ export async function runAssertStep(runtime, assertion, options) {
  * passing is what confirms the traces staged before it at attempt end
  * (cache/context.ts).
  */
-export async function dispatchAgentStep(runtime, spec, 
+export async function dispatchAgentStep(runtime, raw, 
 // Resolved before the step opens, so an unknown name fails the call, not a
 // recorded step, and the step carries the agent it ran with.
-agent = runtime.select(spec.agent)) {
+agent = runtime.select(raw.agent)) {
+    const spec = redactSpec(raw, runtime.redact);
+    // Redacted per step, not once per agent: the ledger is live, so a value
+    // resolved since the agent was selected is covered too.
+    const context = agent.agentContext === undefined ? undefined : runtime.redact(agent.agentContext);
     return runtime.steps.run('agent', spec.api, spec.instruction, async () => {
-        const dispatch = new ActDispatch(runtime, spec, agent);
+        const dispatch = new ActDispatch(runtime, spec, { ...agent, agentContext: context });
         try {
             let verdict;
             try {
@@ -108,7 +112,7 @@ agent = runtime.select(spec.agent)) {
             return dispatch.result();
         }
         catch (cause) {
-            await dispatch.conclude(isAgentError(cause) && cause.code === 'CANCELLED' ? 'cancelled' : 'failed');
+            await dispatch.conclude(failedStepOutcome(cause));
             throw cause;
         }
         finally {
@@ -116,6 +120,20 @@ agent = runtime.select(spec.agent)) {
         }
     }, { verifies: spec.kind === 'assert', agent: agent.name });
 }
+/**
+ * The spec with every registered secret value the test spelled into the
+ * instruction or a param string (a key or a leaf) rewritten to its marker,
+ * before anything reads it: the executor, its model, the step label, the
+ * trace cache, and the prior-step ledger all see the same redacted step. A
+ * `Secret` handle is already a placeholder here and stays fillable through
+ * `typeSecret`.
+ */
+function redactSpec(spec, redact) {
+    const instruction = redact(spec.instruction);
+    if (spec.params === undefined)
+        return { ...spec, instruction };
+    return { ...spec, instruction, ...redactParams(spec.params, spec.templates, redact) };
+}
 /** One step's wiring: the collaborators, the executor's context, and the verdict mapping. */
 class ActDispatch {
     runtime;
@@ -465,4 +483,3 @@ function screenOf(observation) {
         ? { ...metadata, kind: 'semantic', nodes: observation.nodes }
         : { ...metadata, kind: 'pixels' };
 }
-//# sourceMappingURL=act.js.map

package/dist/agent/action-dispatcher.d.ts

@@ -184,4 +184,3 @@ export declare class ActionDispatcher {
     /** The seam a policy records its decisions through, onto this step's events. */
     private policyHost;
 }
-//# sourceMappingURL=action-dispatcher.d.ts.map

package/dist/agent/action-dispatcher.js

@@ -598,4 +598,3 @@ function isInViewport(rect, viewport) {
         return true;
     return rect.x < viewport.width && rect.y < viewport.height && rect.x + rect.width > 0 && rect.y + rect.height > 0;
 }
-//# sourceMappingURL=action-dispatcher.js.map

package/dist/agent/action-names.d.ts

@@ -25,4 +25,3 @@ export declare const HARNESS_TOOL_NAMES: ReadonlyMap<string, string>;
  * take one: it would be silently shadowed on one engine and live on another.
  */
 export declare const GRAMMAR_TOOL_NAMES: ReadonlySet<string>;
-//# sourceMappingURL=action-names.d.ts.map

package/dist/agent/action-names.js

@@ -78,4 +78,3 @@ export const GRAMMAR_TOOL_NAMES = new Set([
     'select_at',
     'dismiss_keyboard',
 ]);
-//# sourceMappingURL=action-names.js.map

package/dist/agent/actions.d.ts

@@ -134,4 +134,3 @@ export declare function describeAction(action: RecordableAction, redact: (text:
  * node is named, not what it contains.
  */
 export declare function describeTarget(node: SemanticNode, redact: (text: string) => string): TraceTargetDescriptor | undefined;
-//# sourceMappingURL=actions.d.ts.map

package/dist/agent/actions.js

@@ -193,4 +193,3 @@ function describeWhere(target) {
 function quote(value) {
     return JSON.stringify(bound(value, 40));
 }
-//# sourceMappingURL=actions.js.map

package/dist/agent/agent-brand.d.ts

@@ -11,4 +11,3 @@ export declare const BUILT_IN_AGENT: {
     readonly name: 'e2e-default-agent';
     readonly version: '2';
 };
-//# sourceMappingURL=agent-brand.d.ts.map

package/dist/agent/agent-brand.js

@@ -8,4 +8,3 @@
  * valid whatever options an agents entry sets.
  */
 export const BUILT_IN_AGENT = { name: 'e2e-default-agent', version: '2' };
-//# sourceMappingURL=agent-brand.js.map

package/dist/agent/ai-sdk.d.ts

@@ -19,9 +19,15 @@ export type SdkLanguageModel = Exclude<LanguageModel, string>;
 export declare function asSdkLanguageModel(instance: ModelInstance): SdkLanguageModel;
 /** Loads and caches the AI SDK, or fails with MODEL_UNAVAILABLE. */
 export declare function loadAiSdk(): Promise<AiSdk>;
+/**
+ * The SDK when the optional peer is installed, else undefined: for the seams
+ * that have a way to do their job without it.
+ */
+export declare function loadAiSdkIfInstalled(): Promise<AiSdk | undefined>;
+/** The SDK when an earlier call loaded it, else undefined; never loads it. */
+export declare function loadedAiSdk(): AiSdk | undefined;
 /**
  * The already-loaded SDK, for the few synchronous seams (error-class checks)
  * that run strictly after an async caller primed the cache.
  */
 export declare function aiSdk(): AiSdk;
-//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/agent/ai-sdk.js

@@ -53,6 +53,17 @@ export async function loadAiSdk() {
         throw missing(state.failure);
     }
 }
+/**
+ * The SDK when the optional peer is installed, else undefined: for the seams
+ * that have a way to do their job without it.
+ */
+export async function loadAiSdkIfInstalled() {
+    return loadAiSdk().catch(() => undefined);
+}
+/** The SDK when an earlier call loaded it, else undefined; never loads it. */
+export function loadedAiSdk() {
+    return cache().loaded;
+}
 /**
  * The already-loaded SDK, for the few synchronous seams (error-class checks)
  * that run strictly after an async caller primed the cache.
@@ -69,4 +80,3 @@ function missing(cause) {
         'peer dependency ai@^7 — install it, or configure an agent that brings ' +
         'its own model transport', { cause });
 }
-//# sourceMappingURL=ai-sdk.js.map

package/dist/agent/call-options.d.ts

@@ -7,4 +7,3 @@
 export declare function resolveTimeout(requested: number | undefined, fallback: number): number;
 /** Resolves a per-call budget override, capped at the configured limit. */
 export declare function resolveBoundedBudget(requested: number | undefined, limit: number, label: string): number;
-//# sourceMappingURL=call-options.d.ts.map

package/dist/agent/call-options.js

@@ -25,4 +25,3 @@ export function resolveBoundedBudget(requested, limit, label) {
     }
     return requested;
 }
-//# sourceMappingURL=call-options.js.map

package/dist/agent/default-agent.d.ts

@@ -28,4 +28,3 @@ export declare function createBuiltInAgent(options?: BuiltInAgentOptions): StepE
  * and a host outside the loop reports them its own way.
  */
 export declare function projectTools(context: StepExecutorContext, tools: Readonly<Record<string, AgentTool>>): ToolSet;
-//# sourceMappingURL=default-agent.d.ts.map

package/dist/agent/default-agent.js

@@ -170,4 +170,3 @@ function guardedTools(helpers, tools) {
     }
     return guarded;
 }
-//# sourceMappingURL=default-agent.js.map

package/dist/agent/derived.d.ts

@@ -57,4 +57,3 @@ export interface StepEvidence {
  * the model composed itself.
  */
 export declare function derivedReason(value: string, instruction: string, params: Readonly<Record<string, JsonValue>> | undefined, evidence?: StepEvidence): DerivedReason | undefined;
-//# sourceMappingURL=derived.d.ts.map

package/dist/agent/derived.js

@@ -125,4 +125,3 @@ function paramStrings(params) {
 function normalize(text) {
     return text.toLowerCase().replace(/\s+/g, ' ').trim();
 }
-//# sourceMappingURL=derived.js.map

package/dist/agent/error.d.ts

@@ -10,16 +10,29 @@ import type { AgentErrorCode } from '../types.ts';
 export type BlockedCategory = 'credentials' | 'environment' | 'seed_data' | 'test_setup' | 'automation';
 /**
  * The single source of truth for the closed agent code set: exit/result class
- * for every code, plus the blocked category for codes a `blocked` verdict may
- * carry. The model never selects a code, a category, or a blocked category —
- * everything derives from this table.
+ * for every code, the blocked category for codes a `blocked` verdict may
+ * carry, and whether the code means no model answered at all. The model never
+ * selects a code, a category, or a blocked category — everything derives from
+ * this table.
  */
 export declare const AGENT_CODE_TABLE: Readonly<Record<AgentErrorCode, {
     category: ErrorCategory;
     blockedCategory?: BlockedCategory;
+    modelUnreachable?: true;
 }>>;
 /** Exit/result class per code; derived from the one table. */
 export declare const CATEGORY_BY_CODE: Readonly<Record<AgentErrorCode, ErrorCategory>>;
+/**
+ * True when a failure means no model answered: none was configured, the
+ * provider returned an error (a rejected or missing key, a rate limit, a
+ * 5xx), or the stall guard cut off a request that got no response. Such a
+ * failure is a verdict on the model's reachability, never on the app, so it
+ * implicates no recorded flow. A model that answered with something unusable
+ * (`MODEL_OUTPUT_INVALID`, `CONTEXT_OVERFLOW`) or a step that ran out of time
+ * (`STEP_TIMEOUT`, even while a request was open) is not this: the screen the
+ * model was shown may be what went wrong.
+ */
+export declare function isModelUnreachable(error: unknown): boolean;
 /**
  * Runner-classified agent failure (spec api/e2e.d.ts). It extends the internal
  * error base so category, exit code, retry eligibility, and report
@@ -51,4 +64,3 @@ export declare function toAgentError(cause: unknown): AgentError;
  * keep honest names and `instanceof` never spans realms.
  */
 export declare function isAgentError(value: unknown): value is AgentError;
-//# sourceMappingURL=error.d.ts.map

package/dist/agent/error.js

@@ -2,9 +2,10 @@
 import { classifyError, E2EError } from '../internal/errors.js';
 /**
  * The single source of truth for the closed agent code set: exit/result class
- * for every code, plus the blocked category for codes a `blocked` verdict may
- * carry. The model never selects a code, a category, or a blocked category —
- * everything derives from this table.
+ * for every code, the blocked category for codes a `blocked` verdict may
+ * carry, and whether the code means no model answered at all. The model never
+ * selects a code, a category, or a blocked category — everything derives from
+ * this table.
  */
 export const AGENT_CODE_TABLE = {
     AUTH_CREDENTIAL_UNAVAILABLE: { category: 'configuration', blockedCategory: 'credentials' },
@@ -17,12 +18,12 @@ export const AGENT_CODE_TABLE = {
     TEST_SETUP_FAILED: { category: 'configuration', blockedCategory: 'test_setup' },
     APP_NOT_OPEN: { category: 'test', blockedCategory: 'test_setup' },
     POLICY_DENIED: { category: 'configuration', blockedCategory: 'test_setup' },
-    MODEL_UNAVAILABLE: { category: 'configuration', blockedCategory: 'automation' },
+    MODEL_UNAVAILABLE: { category: 'configuration', blockedCategory: 'automation', modelUnreachable: true },
     AUTOMATION_UNSUPPORTED: { category: 'test', blockedCategory: 'automation' },
     STEP_BUDGET_EXHAUSTED: { category: 'test', blockedCategory: 'automation' },
     STEP_TIMEOUT: { category: 'test', blockedCategory: 'automation' },
     CONTEXT_OVERFLOW: { category: 'test', blockedCategory: 'automation' },
-    MODEL_PROVIDER_FAILED: { category: 'infrastructure' },
+    MODEL_PROVIDER_FAILED: { category: 'infrastructure', modelUnreachable: true },
     CANCELLED: { category: 'infrastructure' },
     AUTHENTICATION_FAILED: { category: 'test' },
     MODEL_OUTPUT_INVALID: { category: 'test' },
@@ -39,7 +40,25 @@ export const AGENT_CODE_TABLE = {
 };
 /** Exit/result class per code; derived from the one table. */
 export const CATEGORY_BY_CODE = Object.fromEntries(Object.entries(AGENT_CODE_TABLE).map(([code, entry]) => [code, entry.category]));
-/** The blocked category a code names, or undefined when it is not blockable. */
+/** The codes that mean no model answered; derived from the one table. */
+const MODEL_UNREACHABLE_CODES = new Set(Object.entries(AGENT_CODE_TABLE)
+    .filter(([, entry]) => entry.modelUnreachable === true)
+    .map(([code]) => code));
+/**
+ * True when a failure means no model answered: none was configured, the
+ * provider returned an error (a rejected or missing key, a rate limit, a
+ * 5xx), or the stall guard cut off a request that got no response. Such a
+ * failure is a verdict on the model's reachability, never on the app, so it
+ * implicates no recorded flow. A model that answered with something unusable
+ * (`MODEL_OUTPUT_INVALID`, `CONTEXT_OVERFLOW`) or a step that ran out of time
+ * (`STEP_TIMEOUT`, even while a request was open) is not this: the screen the
+ * model was shown may be what went wrong.
+ */
+export function isModelUnreachable(error) {
+    if (!(error instanceof E2EError) && !isAgentError(error))
+        return false;
+    return MODEL_UNREACHABLE_CODES.has(error.code);
+}
 /** Cross-realm identity marker, mirroring `internal/errors.ts`. */
 const AGENT_ERROR_MARKER = Symbol.for('e2e.agent-error.v1');
 /**
@@ -99,4 +118,3 @@ export function isAgentError(value) {
         typeof value.code === 'string' &&
         value.code in CATEGORY_BY_CODE);
 }
-//# sourceMappingURL=error.js.map

package/dist/agent/executor.d.ts

@@ -495,4 +495,3 @@ export declare function isRuntimeHardStop(cause: unknown): cause is AgentError;
 export declare const BLOCKABLE_CODES: ReadonlySet<AgentErrorCode>;
 /** Structural executor check, mirroring how model instances are detected. */
 export declare function isStepExecutor(value: unknown): value is StepExecutor;
-//# sourceMappingURL=executor.d.ts.map

package/dist/agent/executor.js

@@ -52,4 +52,3 @@ export function isStepExecutor(value) {
         candidate['name'] !== '' &&
         typeof candidate['runStep'] === 'function');
 }
-//# sourceMappingURL=executor.js.map

package/dist/agent/index.d.ts

@@ -12,4 +12,3 @@ import type { Agent } from '../types.ts';
 import { type AgentContext } from './invocation.ts';
 /** Builds the agent fixture for one attempt. */
 export declare function createAgentFixture(runtime: AgentContext): Agent;
-//# sourceMappingURL=index.d.ts.map

package/dist/agent/index.js

@@ -350,4 +350,3 @@ function safeJson(value) {
         return undefined;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/agent/interactive-step.d.ts

@@ -35,4 +35,3 @@ export interface InteractiveStep {
  * never resolved and the budgets a model loop needs do not apply.
  */
 export declare function openInteractiveStep(runtime: AgentContext, options: InteractiveStepOptions): Promise<InteractiveStep>;
-//# sourceMappingURL=interactive-step.d.ts.map

package/dist/agent/interactive-step.js

@@ -129,4 +129,3 @@ class HostExecutor {
             job.settle({ error: reason });
     }
 }
-//# sourceMappingURL=interactive-step.js.map

package/dist/agent/invocation.d.ts

@@ -210,4 +210,3 @@ export declare class Invocation {
     private modelInfo;
     private consumeModelCall;
 }
-//# sourceMappingURL=invocation.d.ts.map

package/dist/agent/invocation.js

@@ -53,7 +53,7 @@ export class Invocation {
         this.agent = runtime.select(options.agent);
         this.deadline = runtime.engine.deadline(options.timeoutMs);
         this.pixelTier = options.vision === true || options.vision === 'only';
-        this.system = buildSystem(options.task, this.agent.agentContext);
+        this.system = runtime.redact(buildSystem(options.task, this.agent.agentContext));
         this.systemBytes = tokenUpperBound(this.system);
     }
     get session() {
@@ -179,11 +179,17 @@ export class Invocation {
         for (;;) {
             this.checkDeadline();
             this.consumeModelCall();
-            const prompt = buildPrompt({
+            // The observation is redacted already; the instruction is the test's
+            // own text, which may spell out a registered value. The repair's raw
+            // text is redacted before the prompt cuts it, so the cut never splits a
+            // value into a fragment whole-value matching would miss.
+            const prompt = this.runtime.redact(buildPrompt({
                 ...request.prompt,
                 ...(this.treeWithheld ? { withholdTree: true } : {}),
-                ...(repair === undefined ? {} : { repair }),
-            });
+                ...(repair === undefined
+                    ? {}
+                    : { repair: { ...repair, rawText: repair.rawText === undefined ? undefined : this.runtime.redact(repair.rawText) } }),
+            }));
             // Pixels travel with the observation they were captured for, so the
             // image and the tree in one request always describe one revision.
             const images = imagesFor(request.prompt.observation);
@@ -322,4 +328,3 @@ function imagesFor(observation) {
         },
     ];
 }
-//# sourceMappingURL=invocation.js.map

package/dist/agent/ledger.d.ts

@@ -36,4 +36,3 @@ export interface LedgerContext {
  * handoff to the ledger's own line budget.
  */
 export declare function serializeLedger(steps: readonly PriorStep[], maxBytes: number): LedgerContext;
-//# sourceMappingURL=ledger.d.ts.map

package/dist/agent/ledger.js

@@ -72,4 +72,3 @@ function formatEntry(step, position) {
     const handoff = truncateUtf8(step.explanation, MAX_HANDOFF_BYTES);
     return `${head}\n   observed: ${handoff}`;
 }
-//# sourceMappingURL=ledger.js.map

package/dist/agent/loop-guards.d.ts

@@ -84,4 +84,3 @@ export declare function isFailedResult(toolName: string, text: string): boolean;
  * that the last id was. Warns first, then forces the conclusion.
  */
 export declare function checkFailureStreak(results: readonly GuardToolResult[], thresholds?: LoopGuardThresholds): LoopGuardVerdict;
-//# sourceMappingURL=loop-guards.d.ts.map

package/dist/agent/loop-guards.js

@@ -184,4 +184,3 @@ export function checkFailureStreak(results, thresholds = DEFAULT_LOOP_GUARD_THRE
     }
     return { kind: 'clear' };
 }
-//# sourceMappingURL=loop-guards.js.map

package/dist/agent/model/adapter.d.ts

@@ -102,4 +102,3 @@ export declare function imageTokenUpperBound(image: {
     width: number;
     height: number;
 }): number;
-//# sourceMappingURL=adapter.d.ts.map

package/dist/agent/model/adapter.js

@@ -37,4 +37,3 @@ export function imageTokenUpperBound(image) {
     return (Math.ceil(Math.max(1, image.width) / IMAGE_TILE_PX) *
         Math.ceil(Math.max(1, image.height) / IMAGE_TILE_PX));
 }
-//# sourceMappingURL=adapter.js.map

package/dist/agent/model/overflow.d.ts

@@ -17,4 +17,3 @@
  * provider's words.
  */
 export declare function isContextOverflow(error: unknown): boolean;
-//# sourceMappingURL=overflow.d.ts.map

package/dist/agent/model/overflow.js

@@ -79,4 +79,3 @@ function describesOverflow(error) {
         OVERFLOW_PATTERNS.some((pattern) => pattern.test(text)) &&
         !NON_OVERFLOW_PATTERNS.some((pattern) => pattern.test(text)));
 }
-//# sourceMappingURL=overflow.js.map