* fix(mcp): redact secrets from what user code prints in the e2e mcp process
Project tools and the config's top-level code run in the e2e mcp process,
and what they wrote to stdout or stderr reached stderr verbatim. Every
write now goes through StreamRedactor with processSecrets, as an e2e run
worker's output does. Output printed while a config loads is held until
its secrets are registered, and withheld if the load fails.
* fix(mcp): release unfinished lines per call, keep backpressure, redact uncaught errors
* fix(mcp): one redactor for both streams, release tails only with no call in flight, hold uncaught reports during loads
* fix(mcp): release a character cut short at shutdown
* fix(mcp): redact secrets from open_session, close_session, and server logs
An engine or app error carrying a configured secret reached the client
verbatim in a failed open_session or a close_session Cleanup line, and in
the server's log lines. Every fixed tool's result or failure now passes
processSecrets, the config's static secrets join it as soon as the config
loads, the teardown text passes the session ledger (it is also the stderr
shutdown summary), and host log lines are redacted.
* fix(mcp): redact shutdown text with every known secret, scope docs claim to loaded configs
* fix(web): provision the chromium build the run launches
A first run downloaded the full chromium build, and its own headless launch
never needed it, while a machine holding only the full build (`install
--no-shell`) read as installed and then failed to launch the shell it
needed. The check now answers for the build the run launches, and the run
mode reaches the install, so a headed run provisions for its window.
Rebased onto the pinned playwright-core: this used `playwrightCliPath` and
`require.resolve('playwright/package.json')`, neither of which exists after
#798, so the install of a first run would have failed at runtime. The
`PLAYWRIGHT_SKIP_BROWSER_GC=1` the install spawns with is kept, so it still
adds what the run needs without collecting the revisions other tools share
that cache with, and `e2e-web install` now collects nothing for the same
reason.
`EnginePrepareInfo.headed` is required, alongside the `headed` an engine
already receives on `init`.
* test(web): exercise the built-in check and the shell-only install
The build-selection tests re-implemented the check instead of calling it,
so breaking `isBrowserInstalled` left them green, and nothing asserted
`--only-shell` at all. They now run the shipped check from the built
package against a real browser cache laid out per build, in a child process
because Playwright resolves its cache when it first loads and this file has
already loaded it, and they assert `installArgs` for both run modes.
* test: hand the run mode to every prepare fixture
`EnginePrepareInfo.headed` is required now, so each fixture passes it.
* fix(web): platform-correct install test, trim docs and jsdoc
---------
Co-authored-by: Feco Linhares <fecolinhares@users.noreply.github.com>
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
* feat(mcp)!: e2e mcp runs headless by default and takes --headed, like run
Sessions were headed outside CI and took --headless, the opposite of
e2e run and e2e explore. --headless stays accepted and hidden: it now
asks for the default, and a refused flag would reach an MCP host as
nothing but a failed connection.
* docs(skill): --headed shows the UI when the engine supports it
* feat(mcp): open_session takes headed, so the agent picks per session
The server's --headed sets the default for sessions that do not say,
and headed: true or false overrides it, so a user who asks to watch
needs no change to the MCP client config.
* fix(run): serial group failures reach the exit code and the reporters
- exit code folds serial groups: members carry no attempts, so a group's
infrastructure error exited 1, and a launch failure (all members skipped) exited 0
- group attempt that fails before any member runs (launch, file load) fails
the first member with the error, rest skip as serial-predecessor-failed;
an interrupt there skips every member instead
- a retry that never reached its members keeps the verdicts of the attempt before it
- worker crash during a serial member fails that member with WORKER_CRASH
instead of skipping it as never started
* docs(test): an interrupted serial launch skips every member
* fix(secrets): rewrite traces and text downloads whenever the run has a secret value
A registered value a test passed as a plain string (an app.open URL, a fill)
was redacted from titles, labels, and agent input but kept verbatim in
trace.zip: trace and download rewriting was gated on the exposure level,
which only a fill or an engine-held secret raises. Rewriting now depends on
the session ledger holding a value. The engine exposure level had no other
consumer and is removed; exposure now only decides pixels and saved-session
taint.
* fix(secrets): cover a plain-string fill, scope docs to the session's known values
* docs(secrets): download redaction is whole-value; TRACE_WITHHELD outside-path case
* docs(secrets): name the download rewrite failure path
* fix(e2e): load TypeScript with an oxc loader instead of tsx
* fix(e2e): close loader edge cases: sourceless CommonJS, export maps without extensions, unreadable tsconfig, chained source maps, Windows require paths
* fix(e2e): refuse Bun and Deno runtimes, name oxc load failures, follow Yarn PnP export targets
* perf(e2e): skip the syntax check for files whose only @ is in a package import
* fix(e2e): allow type-only exports in .cts, warn from runner only, Bun check first, docs
* fix(e2e): workers warn about tsconfigs runner did not, FILE: urls, foreign infra errors, review tests
* fix(cache): --strict-cache fails a step whose key changed under its recording
A cache key change (REPLAY_POLICY_VERSION, a new key field, an engine minor, the agent's context) turned every committed entry into a no-entry miss, which strict ran live. Strict now lists the file store once per run and fails a no-entry step with REPLAY_STALE when an entry recorded for the same step sits under another key. Entries now record the step's params digest, occurrence, and agent so a repeat or another agent is not mistaken for it.
* fix(cache): never take an entry the attempt claimed for a rekeyed step
An entry from before the occurrence fields matches by test, target, and instruction; an earlier occurrence's entry is now excluded, so an unrecorded repeat runs live. The message no longer says to delete the old entry, which may still serve another app identity.
* fix(cache): match a rekeyed recording only by its whole step
An entry without the params, occurrence, and agent could be another call of the same instruction, so strict now ignores it instead of guessing. A confirmed whole replay in read-write mode writes the missing provenance in, since it proved which step the entry belongs to.
* test(web-benchmark): complete the provenance of 25 agent recordings
Written by a local read-write replay (no model calls); only recordedFor and createdAt change. The 4 gap entries need a live run with a key.
* test(cache): assert the provenance backfill comes from a replay
* feat(web): init scripts run before the page's own, configured with web({ initScripts }) or added per test with browser.addInitScript
* refactor(web): one owner for configured init scripts, read beside the browser launch
* feat(web): export WebInitScript
* fix(web): settle the browser launch before a failed init-script read throws; docs examples compile
* fix(web): refuse sparse initScripts, keep an own __proto__ key in the init-script argument
* docs(web): seed Math.random in the init-script examples
* docs(web): trim init-script docs to what users need
* docs(skill): addInitScript takes arg with a function only
* feat(web)!: pin playwright-core and add an install command
@e2e-dev/web depends on playwright-core 1.63.0 instead of peering on
playwright. New e2e-web bin installs browsers for the pinned version:
npx @e2e-dev/web install chromium --with-deps. e2e init no longer adds
playwright.
* test(web): run the e2e-web bin for real, and in CI
* test(web): spawn the built e2e-web bin so Node 22.12 runs it
* feat(oauth): sign in with OpenCode Console for Zen and Go models
* fix(oauth): keep the Console refresh token, isolate tests from OPENCODE_API_KEY
A refresh grant without a refresh_token now keeps the previous one, as
the ChatGPT and SpaceXAI providers do. The vendor test helper blanks
OPENCODE_API_KEY so a key in the shell no longer replaces the stored
login under test. Docs and changeset now say the models listing covers
Zen and Go only, and that MISCONFIGURED needs a readable workspace config.
device.openLink built its INVALID_ARGUMENT message from the raw input, so a
string that fails to parse as an absolute URL still echoed whatever it
carried. A malformed magic link is exactly the case where a one-time token
sits in that string, and the message reaches logs, the report, and CI
output.
Name no part of the input, the same rule assertAppId already follows in this
file: nothing about a string that failed to parse says which part is safe to
repeat, and a token can sit in the query, the path, or the userinfo. linkLabel
stays for the step label and the report, where the link did parse.
Covered by a unit test over malformed links whose token sits in the query,
the path, and the userinfo.
* feat(web): locale and timezoneId options set the language and time zone every attempt runs in
* docs(web): timezoneId validation is best effort, the browser has the final word
* fix(run): keep --last-failed reruns honest: failure-limit skips, carried debts, kept evidence
--last-failed now reruns tests --max-failures skipped. A test or failed
suite hook another filter leaves out stays owed in the report's new
run.carried until a rerun runs it; the github fold shows carried rows and
errors and stays red while anything is carried. A rerun prunes artifacts/
to what the previous report names and writes its attempts under
artifacts/rerun-<n>/ instead of wiping the tree and reusing attempt paths.
* fix(run): carry a setup's hook debt when no selected test needs it
The report has no row for an unneeded setup, so carryForward now asks the
collection whether a test still exists instead of the report's rows.
* fix(run): reject malformed artifacts in --last-failed reports, tighten rerun docs
Distinct ids in the carried fixture row.
* fix(run): keep carrying tests of a file a narrowed rerun could not collect
* fix(github): a carried interrupted test reads interrupted, not failed, in the folded page
* fix(expect): unawaited poll fails its own phase, slow first read counts toward negation window
- expect.poll is owned by the phase that started it (body, hook, fixture teardown, suite hook); left running it is cancelled and fails that phase with STEP_NOT_AWAITED instead of a later test
- pollCondition starts the negation window when the first read that saw it was issued and decides at the deadline without a read past it
* fix(expect): own polls by async lineage so a timed-out body never charges the next test
* docs(expect): scope STEP_NOT_AWAITED wording to where it surfaces; test reads past body
* fix(web): continue skips earlier routes, decisions take or reject Playwright options
continue went through Playwright fallback, so an earlier route answered. It now continues to the network, merging site headers itself; fallback() keeps chaining. continue takes url/method/headers/postData (url via resolveUrl), fulfill takes path/contentType; unknown options are INVALID_ARGUMENT. waitForResponse timeout bounds the match only; setCookies passes the resolved url.
* fix(web): route header overrides follow the web({ headers }) grammar
* refactor(web): route options reuse rejectUnknownOptions
* test(web): route url fake follows the http(s) navigation allowlist
* fix(web): fulfill keeps a content-type header over the json or path type
* fix(oauth): reach Copilot models served only over the Responses API
copilot() reads the plan's model listing on the first call and picks
chat completions or the Responses API for each model, falling back to
chat whenever the listing cannot be read so nothing that worked changes.
sendCopilotRequest reads the initiator and vision headers from a
Responses body (input[]/input_image) as well as a chat one, and the model
listing marks an uncallable model 'no chat or responses'.
* fix(changeset): schedule a minor release for the Responses endpoint support
The changeset asked for a patch while the change adds a call path a model could not
reach before; a minor bump is what the release intent states.
Addresses the cubic review comment on .changeset/copilot-responses-endpoints.md.
* fix(oauth): cancel and never cache a Copilot endpoint lookup that was aborted
The first call read the plan's model listing with no signal, and the delegate cached
whatever that produced. A listing that stalled therefore left `pending` unresolved and
every retry waited on the same promise instead of reaching the model. The signal now
reaches the lookup, an aborted lookup rejects instead of being read as a missing
endpoint, and a choice that could not be made clears `pending` so the next attempt
asks again. A test pins the aborted lookup and the missing-endpoint read as distinct.
Addresses the cubic review comment on packages/e2e/src/oauth/copilot.ts.
* docs(skill): separate Copilot models served over Responses from uncallable ones
The setup reference read as if every non-chat model is reached over the Responses API.
Only an enabled model the plan serves solely over `/responses` is; a model served over
an API `copilot()` does not speak, or one the plan has not enabled, still cannot be
called, and the listing marks those.
Addresses the cubic review comment on skills/e2e/references/setup.md.
* fix(oauth): pick Copilot endpoint from supported_endpoints alone, retry unreadable listing
- drop policy gate: grok-4.5, gpt-5.3-codex serve /responses with no policy
- unreadable listing: call over chat, not cached, asked again next call
- listing has own 10s timeout; one caller abort no longer fails others
- revoked login fails on listing with sign-in hint, no second 401
- missing @ai-sdk/openai names the package to install
* fix(init): install @ai-sdk/openai for the Copilot gateway
* docs(copilot): unreadable listing retry, init installs both peers
---------
Co-authored-by: Hermes Agent <agent@localhost>
Co-authored-by: Feco Linhares <fecolinhares@users.noreply.github.com>
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
* fix(web): read visibility as rendered, null box, checkable values, embedded names
* fix(web): narrow visible queries by the reader's hidden state
* fix(web): drop direct text a content-visibility hidden element skips
* docs(changeset): note the display contents divergence from Playwright
* fix(security): allow only http(s) navigation, refuse wrapped schemes on device links
view-source:file:// passed the file:/data:/javascript: denylist and loaded local files via app.open, browser.goto, and the navigate verb. resolveNavigationUrl now admits http: and https: only; mobile links also refuse view-source:, blob:, filesystem:.
* fix(security): admit exact about:blank, sync rule text in AGENTS.md and SECURITY.md
* fix(web): refuse about:blank cookie URL, qualify scheme rule text
* fix(mobile): never pin an install's file path as the app app.open() launches
agent-device 0.21.18 can return an Android install with no package (its binary manifest parser misses aapt2 output, and the aapt fallback needs ANDROID_HOME), echoing the APK path as app. The engine pinned that path, so app.open() failed later with 'Android runtime hints require an installed package name'. installApp now opens by the reported id or the app passed in, and fails with ENGINE_FAILURE when there is neither. app.open() keeps the engine's own UNSUPPORTED_CAPABILITY reason instead of a generic rewrite.
* test(mobile): pin the reported package, not the echoed path; clarify installApp failure docs
* fix(runner): preserve failures when tests skip
* refactor(runner): one skipped-after-failure helper, evidence from failing attempt
- failureBeforeSkip returns failing attempt's error, evidence, artifacts; list reporter prints those instead of skipped attempt's
- someSkippedAfterFailure indexes serial groups once, shared by exit code and run status
- collapse skip branch in execute, place failOnSkippedFailure next to retries with JSDoc
---------
Co-authored-by: Oskar Kwaśniewski <oskar@okwasniewski.com>
* docs(models): add an AI SDK provider picker to the Models page
Readers did not see that e2e takes a model from any AI SDK provider. The
Models page now has a provider dropdown with 51 providers from
ai-sdk.dev, and three setup steps that follow the selection: install,
environment, and config.
The steps are four instances of one snippet component. Mintlify
evaluates each snippet export alone, so the instances share the
selection through a store on globalThis and React.useSyncExternalStore.
Code renders with Mintlify's CodeBlock for syntax highlighting.
* docs(models): an unlisted provider's model needs tool calls and images
* fix(report)!: count interrupted tests apart from failures
* fix(report): tell a failed test from its last failed attempt, whatever the cut retry left
* docs(mobile): document physical devices
Closes#766
* docs(mobile): phone requirements in setup and README
* docs(mobile): move physical devices to its own page
* fix(web): read each locate match in the task that finds it
Locate queried matches, then read them in a later protocol call. A page
that replaces a match every frame detached it in between whenever a frame
passed, so on a starved runner every retry read a detached match and
the locate livelocked until the action timeout (LOCATOR_NOT_FOUND, node
became stale). The pinned label/display-value path had the widest gap.
A new e2e-read selector engine, appended to the projected locator, reads
each match inside the query and records the read on the element under a
per-locate token; locate takes the reads back from the returned elements
(or from the pinned handles). The detached-read plumbing is gone.
* fix(web): refuse a capture selector the locate read cannot follow
* test(e2e): starve the runner with Atomics.wait, not a spinning core
* fix(mcp): open a session without the optional ai package
* docs(changeset): word the mcp entry for what changed
* docs(mcp): JSDoc on the Standard Schema helpers
* docs(mcp): the server needs no model package
---------
Co-authored-by: oskar <oskar@okwasniewski.com>
* fix(expect): matcher options are honored or rejected, never silently ignored
* refactor(web): reuse core rejectUnknownOptions, presence toHaveAttribute reads third arg
- e2e/engine exports rejectUnknownOptions; web drops its timeout-only copy
- toHaveAttribute(name, undefined, options) validates and times out on options
- waitForURL waitUntil refusal tested and noted in migration table
* docs(engine): rejectUnknownOptions takes code, options must be plain object
* fix(expect): toHaveAttribute refuses a null value or options; tests use the @e2e-dev scope
* fix(expect): use the browser fixture name after the web rename
* fix(cache): a failure where no model answered evicts no recording
MODEL_PROVIDER_FAILED and MODEL_UNAVAILABLE say nothing about the app. A step that fails with one concludes with no verdict (like a cancellation), and the attempt settles with implicatesUnconfirmed false: confirmed steps are still written, unconfirmed entries stay as stored.
* fix(cache): a later app failure still implicates unconfirmed entries
Settlement reads every failure in the attempt, not only the first: an afterEach assertion failing after a provider failure evicts what nothing confirmed.
* docs: agent prompt quickstart, why-e2e intro, separate API testing page
* docs(api-testing): keep the signed-in fixture's cookies on the app origin
* test(skill): walk the docs without entering node_modules
Node 22's recursive readdirSync followed the workspace symlink loop under
docs/node_modules and failed with ELOOP before the filter could drop it.
* feat(eas): authenticate with the eas-cli login when EXPO_TOKEN is not set
easSimulators() now reads the session eas login keeps in ~/.expo/state.json
(under USERPROFILE on Windows, HOME elsewhere) and sends it as the
expo-session header, as eas-cli does. EXPO_TOKEN still wins and goes out as
Authorization: Bearer. Only the production login is read, since the sessions
API is always api.expo.dev. release stops each session with the client that
created it, so a logout or account switch during the run cannot strand a
billed session.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(eas): keep the lease's client until stop succeeds; separate local credential errors in docs
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(skill): declare the app on the target in skill and docs config examples
The bundled skill and docs/authentication.mdx still taught web({ url, command }), removed in #698. The skill's two config examples now live in docs/examples/skill/, typechecked and mirrored by check-docs-examples, so the old shape fails pnpm check.
* fix(skill): run the docs drift check on skill changes, drop stale service wording
* feat!: browser fixture, getByRole name arg, toMatchSchema, top-level hooks, separate credential namespace
API review feedback before launch:
- web fixture renamed browser (Web -> Browser, WebExpectation ->
BrowserExpectation); requires: ['browser']; destructuring web hints the
new name. web() factory and other Web* types unchanged.
- getByRole(role, name, options?) beside the object form; MCP locate
writes the short form.
- expect(value).toMatchSchema(standardSchema): sync, returns the typed
output; poll resolves to it, soft returns undefined after a kept failure.
- describe, beforeEach, afterEach, beforeAll, afterAll exported from e2e;
web and mobile export typed beforeEach/afterEach.
- credentials and secrets are separate namespaces: a password handle is
<name>.password, secrets.get() never returns it. Committed recordings
migrated offline (old key hash verified, then recomputed).
- runtime test.skip keeps Playwright semantics; docs say it throws.
* docs(web): browser acts on one active tab; cookies, routes, dialogs cover the whole browser
* fix(secrets): judge a fill's purpose by the config, not the handle; no old-name hints
A config-time secrets.get() handle reads its purpose from the run's
registry again, and authorizeSecretFill checks the registered purpose, so a
handle claiming generic-secret cannot put a password into a plain field.
Drop the web fixture migration hint. Changesets name the on-screen marker
change for replay entries.
* docs(skill): browser fixture, getByRole name arg, toMatchSchema, top-level hooks, credential namespace on the rewritten skill
* fix(expect): negated toMatchSchema returns nothing, as its type says
* fix(expect,docs): soft double negation stays soft, null ~standard is INVALID_ARGUMENT, Playwright samples keep Playwright's getByRole
Also documents SoftExpectCall, SoftValueExpectation, and NegatedPollExpectation
on the expect reference, requires: ['browser'] in the skill's options table,
and tightens the poll and secret-purpose tests.
* docs(babysit): triage pattern for scripted renames that rewrite another library's code
* docs: engine options take a secrets entry, web package hook exports, vault example imports
* refactor(secrets)!: credentials hold their password, allSecrets feeds fills; engines export describe and every hook; BrowserRoute, BrowserResponse
From the maintainability review:
- ResolvedConfig.secrets is the config.secrets entries only; a credential
carries its password; allSecrets is the one map fills, the ledger, and
redaction read. The per-consumer purpose filters and the .password
suffix parsing are gone, and e2e mcp builds handles from config.
- The config load and a running test name the credential a missing
secrets.get() most likely meant.
- @e2e-dev/web and @e2e-dev/mobile export describe and all four hooks
beside test, so a test file registers from one import.
- WebRoute and WebResponse are BrowserRoute and BrowserResponse.
- getByRole normalizes its arguments once; isTextMatch is the one
string-or-RegExp check; poll reuses ValueMatcherName.
* revert(web): keep WebRoute and WebResponse; Browser names the fixture, Web the network and option types
* feat!: the app is declared on its target; engines only drive it
The app under test moves from the engine's options to `targets: [{ engine,
app }]`: `url`, `bundleId`, `appPath`, `identity`, `environment`,
`launchArguments`, `permissions`, `command`, and `readyUrl`. `web()` and
`mobile()` refuse every moved option in one `INVALID_CONFIG` naming the
target block; `defineEngine({ app })` is gone and engines check what their
platform needs in `validateApp`. `requires: ['browser' | 'native-app']` is
derived from the target's app. Replay cache and session keys are byte for
byte what they were, pinned by target-identity.test.ts.
Dependency services are not part of this version: `services` anywhere, and
`web({ services })`, fail saying so. `app.command` on port 0 without a
command, and `reuseExisting` on a free port, are refused. An `e2e mcp`
open cancelled or disconnected mid-start stops what it started, and a hung
shared start is abandoned once no session waits on it.
* fix: review follow-ups: cancelled opens, abandoned starts, null targets, stale docs
* refactor: drop the moved-option messages; old app keys are unknown keys
* test: give the replaced-nodes suite a budget that survives a loaded runner
* test: size the replaced-nodes hook budget to its seven tests
* fix(agent): extract reports absent data instead of inventing it
Send the caller schema's shape only (no min/max/length/pattern/format) inside
an agent-extract-2 envelope { found, value, missing }. found: false fails the
step ASSERTION_INCONCLUSIVE naming what was missing; the repair round may
decline instead of bending a value to fit. Explore covers a declined plan like
an invalid one.
* fix(cache): ignore a gap's derived rule when comparing re-recorded flows
derived follows how the agent read the value on that run (pixels vs node),
never what a replay does, so read-write runs rewrote committed entries.
* fix(agent): stop blaming a control for an unchanged tree without pixel proof
Tree-only unchanged result now says no listed node changed and a drawn
change needs a screenshot; "no visible effect" only when an identical
screenshot backs it. With no screenshot to be had (secret filled, engine
captures none), an unchanged listing still says to try another way.
* fix(cache): REPLAY_STALE names the strict knob and configured cache dir
Was hardcoded to --strict-cache and .e2e/cache even when cache.strict or
cache.dir came from config.
* fix(web): names read generated content and drop icon-font glyphs
The tree named <button><i class="fa fa-sign-in"> Login</i></button> "Login"
while getByRole read the ::before glyph and found nothing. Names now read
::before/::after content as accname, Chrome, and Playwright do; private-use
glyphs are dropped from the reported name, and a role query's string name
tolerates them in the browser's name.
* fix(web,kernel): waitForDownload works on a Kernel browser
A remote browser saves downloads to its own disk, so Playwright's saveAs
over CDP always failed with 'canceled'. BrowserProvider gains an optional
downloads { dir, read }: the engine points the context's downloads at dir
on the browser's machine and reads the finished file back. kernel()
implements it with the browser filesystem API. Without it, the failure
names the provider.
* fix(web): forward worker-side lease progress to the reporter
Attempt-scope and replacement leases were acquired with a discarded log,
so Kernel's live-view line never showed. Use the worker's init log.
* fix(web,kernel): sweep leases a dead worker left open
A worker killed mid-attempt in kernel({ scope: 'attempt' }) leaked its
browser until Kernel's timeout. BrowserProvider gains an optional sweep,
called once per target in finish after the held leases are released;
kernel() deletes every active browser tagged with the run and target.
* fix(web,e2e): name persistent-context limits early
app.clearState() in attempt scope said 'engine web does not implement it';
the engine now refuses it naming the mode. A session consumed on a target
without a state capability fails selection with COLLECTION_ERROR instead
of failing session.save() after the setup test logged in.
* fix(kernel): trim Kernel error messages; docs: attempt scope rules out userAgent
The SDK keeps the newline Kernel ends an error body with, splitting the
run's error line. Trim every SDK failure's message.
* fix(web): absolute downloads.dir; crosscheck spaces glyphs as the tree does
Also guards the provider-downloads test cleanup and notes in the changeset
that a role query by a glyph-only control's title finds nothing.
* feat(cli): e2e feedback sends a report about e2e to the team
One PostHog event with the report and anonymous machine facts; secret-named
env values and token shapes redacted first. --dry-run prints it. A saved
telemetry disable does not stop it; E2E_TELEMETRY_DISABLED and DO_NOT_TRACK do.
* docs(cli): feedback redacts secret-named values of six characters or more
* fix(cli): feedback counts limits in characters, never claims an unconfirmed report was lost
* test(skill): fail a skill or docs paragraph that passes the removed --artifacts
* fix(config): name the replacement for a removed createAgent import
* fix(config): keep the code of a config error raised while the config evaluates
* fix(secrets): refuse a secrets.get() reference where a string is needed
* fix(config): reject unknown keys in engine, command, test, and query options
* fix(config): refuse a tests entry naming a directory, name the ! entry excluding a positional
* refactor(config): derive option key lists from their types
* fix(config): one shared unknown-key check; drop undefined env values
Setup and describe option keys typed from their interfaces; a directory tests entry is INVALID_GLOB like a trailing slash.
* fix(collect): name the excluding ! entry when exclusions left nothing, and in on-disk casing
* fix(config): address review - exclusion hint for bare names, array env, qualified hints
* test(select): use a missing tmp root, not /root, which CI cannot stat
* fix(mobile): accept videoTouches, added on main by #671, in the mobile() key list
* fix(mobile): reject unknown permission names and states in mobile() and device.openApp
Names and states are checked against DevicePermission and PermissionState
through satisfies-typed key lists. INVALID_CONFIG at load, INVALID_ARGUMENT
from device.openApp, before any device command. rejectUnknownKeys takes an
optional code for the test-time case.
* fix(eas): reject unknown easSimulators() options with INVALID_CONFIG
Its options are its own, mapped onto EAS's create input, not a passed-through
SDK body, so a typo such as buildID was dropped silently. Its two other option
refusals are INVALID_CONFIG too. e2e is now a peer, for e2e/engine.
* fix(mobile): require a plain object for permissions; clarify eas and permission notes
A Map passed the object check with no own keys, and the preset applied none
of it.
* fix(agent): resend a stalled model request; keep turns of a timed-out step
One provider request with no response held the step until its own timeout
(an explore step spent 220s of 240s on a single call). Each generate
request is now bounded at 120s and fails as a retryable provider error, so
the SDK's transport retries resend it; the turn notes it. Turns attach as
each ends, so a step the clock settles keeps them, and loop notes survive
the report's per-turn clip.
* fix(agent): abandon a stalled request whose provider ignores the abort
* docs(changeset): say where a first-turn stall note shows
* fix(agent): clear the stall timer when a provider throws synchronously
* fix(web): leave Ctrl-C to the runner, not Playwright's signal handlers
* fix(run): a worker killed by Ctrl-C while starting is not a boot failure
* fix(run): stop a running file at --max-failures without waiting for the interrupt
* fix(mcp): claim a session's config before evaluating it
* fix(mcp): close sessions and exit 0 when the client goes away
* fix(agent): lead a failed action with the attempt and its code; MCP isError
* fix(run): excuse only the workers one Ctrl-C reached, so a signalled boot loop still fails
* fix(web): keep Playwright's SIGHUP handler; it closes the browser on a hangup