ace-test-runner-e2e 0.29.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 ACE Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+<div align="center">
+  <h1> ACE - Test Runner E2E </h1>
+
+  Agent-executed end-to-end tests with reproducible sandboxes and structured reporting.
+
+  <img src="https://raw.githubusercontent.com/cs3b/ace/main/docs/brand/AgenticCodingEnvironment.Logo.XS.jpg" alt="ACE Logo" width="480">
+  <br><br>
+
+  <a href="https://rubygems.org/gems/ace-test-runner-e2e"><img alt="Gem Version" src="https://img.shields.io/gem/v/ace-test-runner-e2e.svg" /></a>
+  <a href="https://www.ruby-lang.org"><img alt="Ruby" src="https://img.shields.io/badge/Ruby-3.2+-CC342D?logo=ruby" /></a>
+  <a href="https://opensource.org/licenses/MIT"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-blue.svg" /></a>
+
+</div>
+
+> Works with: Claude Code, Codex CLI, OpenCode, Gemini CLI, pi-agent, and more.
+
+[Getting Started](docs/getting-started.md) | [Usage Guide](docs/usage.md) | [Handbook - Skills, Agents, Templates](docs/handbook.md)
+
+![ace-test-runner-e2e demo](docs/demo/ace-test-runner-e2e-getting-started.gif)
+
+`ace-test-runner-e2e` runs realistic workflow scenarios through coding agents so teams can validate behavior beyond unit and integration coverage while keeping execution reproducible and isolated from the working tree.
+
+## How It Works
+
+1. Discover E2E scenario definitions from package-local `test/e2e/` suites with metadata, tags, and command flows.
+2. Execute scenarios inside reproducible sandboxes that isolate agent runs from the working tree.
+3. Produce structured reports that are easy to inspect, compare across runs, and feed back into triage workflows.
+
+## Use Cases
+
+**Validate real developer workflows end-to-end** - use `/as-e2e-run` or run `ace-test-e2e` to confirm that instructions, tooling, and outputs behave correctly under agent execution for any package.
+
+**Run broad regression sweeps across packages** - use `ace-test-e2e-suite` for cross-package scenario orchestration with filtering by package, tags, and prior failures.
+
+**Keep execution deterministic and reviewable** - execute in sandboxes with structured outputs so results are reproducible and easy to compare across runs, complementing fast loops from [ace-test-runner](../ace-test-runner). Use `ace-test-e2e-sh` to run ad-hoc commands inside a test sandbox.
+
+**Create and maintain E2E scenarios** - use `/as-e2e-create` to scaffold new scenarios and `/as-e2e-rewrite` or `/as-e2e-fix` to keep existing ones current as workflows evolve.
+
+**Plan E2E coverage for new features** - use `/as-e2e-plan-changes` to map which scenarios need updates when instructions or tooling change, and `/as-e2e-review` to audit scenario quality.
+
+---
+[Getting Started](docs/getting-started.md) | [Usage Guide](docs/usage.md) | [Handbook - Skills, Agents, Templates](docs/handbook.md) | Part of [ACE](https://github.com/cs3b/ace)

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+# Alias for CI compatibility
+task spec: :test
+
+task default: :test

data/exe/ace-test-e2e

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/ace/test/end_to_end_runner"
+require "ace/support/cli"
+
+# Start ace-support-cli single-command entrypoint with exception-based exit code handling (per ADR-023)
+args = ARGV.empty? ? ["--help"] : ARGV
+
+begin
+  Ace::Support::Cli::Runner.new(Ace::Test::EndToEndRunner::CLI::Commands::RunTest).call(args: args)
+rescue Ace::Support::Cli::Error => e
+  warn e.message
+  exit(e.exit_code)
+end

data/exe/ace-test-e2e-sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ace-test-e2e-sh - Execute commands within E2E test sandbox
+#
+# Usage:
+#   ace-test-e2e-sh <test-dir> <command...>
+#   ace-test-e2e-sh <test-dir> bash <<'SANDBOX'
+#     git add . && git commit -m "test"
+#   SANDBOX
+
+# Handle --help/-h before shifting arguments
+if ARGV.first && %w[--help -h].include?(ARGV.first)
+  puts <<~HELP
+    NAME
+      ace-test-e2e-sh - Execute commands within E2E test sandbox
+
+    USAGE
+      ace-test-e2e-sh <test-dir> [command...]
+
+    ARGUMENTS
+      test-dir                          Sandbox directory path (must be under .ace-local/test-e2e/)
+      command                           Command to execute inside the sandbox
+
+    OPTIONS
+      --help, -h                        Show this help
+
+    EXAMPLES
+      $ ace-test-e2e-sh /path/to/sandbox bash
+      $ ace-test-e2e-sh /path/to/sandbox git add . && git commit -m "test"
+  HELP
+  exit 0
+end
+
+if ARGV.first == "--version"
+  require_relative "../lib/ace/test/end_to_end_runner/version"
+  puts "ace-test-e2e-sh #{Ace::Test::EndToEndRunner::VERSION}"
+  exit 0
+end
+
+test_dir = ARGV.shift
+
+unless test_dir
+  warn "Usage: ace-test-e2e-sh <test-dir> [command...]"
+  exit 1
+end
+
+test_dir = File.expand_path(test_dir)
+
+unless test_dir.include?("/.ace-local/test-e2e/")
+  warn "FATAL: Not a sandbox path: #{test_dir}"
+  exit 1
+end
+
+unless Dir.exist?(test_dir)
+  warn "FATAL: Sandbox directory not found: #{test_dir}"
+  exit 1
+end
+
+Dir.chdir(test_dir)
+ENV["PROJECT_ROOT_PATH"] = test_dir
+
+if ARGV.empty?
+  exec "bash"
+else
+  exec(*ARGV)
+end

data/exe/ace-test-e2e-suite

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/ace/test/end_to_end_runner"
+require "ace/support/cli"
+
+# Start ace-support-cli single-command entrypoint with exception-based exit code handling (per ADR-023)
+begin
+  Ace::Support::Cli::Runner.new(Ace::Test::EndToEndRunner::CLI::Commands::RunSuite).call(args: ARGV)
+rescue Ace::Support::Cli::Error => e
+  warn e.message
+  exit(e.exit_code)
+end

data/handbook/guides/e2e-testing.g.md

@@ -0,0 +1,124 @@
+---
+doc-type: guide
+title: E2E Testing Guide
+purpose: Conventions and best practices for agent-executed end-to-end tests
+ace-docs:
+  last-updated: 2026-03-12
+  last-checked: 2026-03-21
+---
+
+# E2E Testing Guide
+
+## Overview
+
+E2E tests are executed by an AI agent and reserved for behaviors that require real CLI execution, real tools, and real filesystem side effects.
+
+## Canonical Conventions
+
+- CLI split:
+  - `ace-test-e2e` runs tests for a single package
+  - `ace-test-e2e-suite` runs suite-level execution
+- Scenario IDs follow `TS-<PACKAGE_SHORT>-<NNN>[-slug]`
+- Test format is standalone pair only:
+  - `TC-*.runner.md`
+  - `TC-*.verify.md`
+  - `runner.yml.md`
+  - `verifier.yml.md`
+- TC artifacts use `results/tc/{NN}/`
+- Summary reports use `tcs-passed`, `tcs-failed`, `tcs-total`, and `failed[].tc`
+- Scenarios declare `tags` for discovery-time filtering via `--tags`/`--exclude-tags`
+
+## Runner vs Verifier Contract
+
+- Runner is **execution-only**:
+  - perform user-like CLI actions in sandbox
+  - produce evidence files under `results/tc/{NN}/`
+  - do not issue PASS/FAIL verdicts
+  - do not perform verifier-style assertion/classification
+- Verifier is **verification-only**:
+  - evaluate TC outcome from sandbox evidence
+  - apply an **impact-first** evidence order:
+    1. sandbox/project state impact
+    2. explicit TC artifacts
+    3. debug captures (`stdout`, `stderr`, `*.exit`, metadata) only as fallback
+- Setup ownership:
+  - sandbox preparation belongs to `scenario.yml` `setup:` + `fixtures/`
+  - TC runner files must not define independent environment setup procedures
+
+## E2E Value Gate
+
+Before adding a TC, confirm the behavior needs:
+- full CLI binary execution
+- real external tools/processes
+- real filesystem I/O and environment state
+
+If not, keep coverage in unit/integration tests.
+
+## Cost and Scope
+
+- Keep scenarios small and coherent.
+- Typical scenario size: 2-5 TCs.
+- Consolidate assertions that share the same command/setup into one TC.
+- Use `cost-tier` to stage execution (`smoke` → `happy-path` → `deep`).
+
+## Execution Pipeline
+
+CLI providers (`ace-test-e2e`, `ace-test-e2e-suite`) use a deterministic 6-phase pipeline:
+
+1. **Setup** — `SetupExecutor` creates sandbox (git init, mise.toml, .ace symlinks, results/tc/{NN}/ dirs)
+2. **Runner prompt** — `SkillPromptBuilder` assembles context from `runner.yml.md` and `TC-*.runner.md`
+3. **Runner LLM** — Agent executes TC steps in sandbox, produces artifacts
+4. **Verifier prompt** — `SkillPromptBuilder` assembles context from `verifier.yml.md` and `TC-*.verify.md`
+5. **Verifier LLM** — Independent agent evaluates artifacts against expectations
+6. **Report** — `PipelineReportGenerator` produces deterministic summary from verifier output
+
+API providers use a single-prompt approach (runner and verifier in one pass).
+
+The verifier is always-on for standalone goal-mode TCs in the CLI pipeline. For procedural runs guided by `ace-bundle wfi://e2e/run`, the verifier is opt-in via `--verify`.
+
+## Scenario Layout
+
+```text
+{package}/test/e2e/TS-{AREA}-{NNN}-{slug}/
+  scenario.yml
+  runner.yml.md
+  verifier.yml.md
+  TC-001-{slug}.runner.md
+  TC-001-{slug}.verify.md
+  fixtures/
+```
+
+## Required Scenario Evidence
+
+In `scenario.yml`, record:
+- `tags` (cost-tier tag + use-case tags)
+- `e2e-justification`
+- `unit-coverage-reviewed`
+- `cost-tier`
+
+This prevents duplicate assertions across test layers.
+
+## Authoring Rules
+
+- Keep runner goals outcome-oriented and deterministic.
+- Keep verifier expectations impact-first, then artifacts, then debug fallback.
+- Preserve strict TC pairing (`runner` + `verify`).
+- Keep outputs inside `results/tc/{NN}/`.
+- Avoid hidden dependencies between TCs unless explicitly intended.
+
+## Execution Artifacts
+
+Reports are written under `.ace-local/test-e2e/`:
+- `{run-id}-{pkg}-{scenario}-reports/summary.r.md`
+- `{run-id}-{pkg}-{scenario}-reports/experience.r.md`
+- `{run-id}-{pkg}-{scenario}-reports/metadata.yml`
+
+## Review Checklist
+
+Before approving new/updated E2E tests:
+- [ ] Scenario uses standalone pair format only
+- [ ] `scenario.yml` omits legacy `mode` and `execution-model`
+- [ ] `runner.yml.md` and `verifier.yml.md` exist
+- [ ] Every TC has both `.runner.md` and `.verify.md`
+- [ ] Artifacts are scoped to `results/tc/{NN}/`
+- [ ] Value-gate metadata is present (`e2e-justification`, `unit-coverage-reviewed`, `cost-tier`)

data/handbook/guides/scenario-yml-reference.g.md

@@ -0,0 +1,182 @@
+---
+doc-type: guide
+title: scenario.yml Reference
+purpose: Complete schema reference for TS-format scenario configuration files
+ace-docs:
+  last-updated: 2026-03-18
+  last-checked: 2026-03-21
+---
+
+# scenario.yml Reference
+
+## Overview
+
+The `scenario.yml` file configures a TS-format E2E scenario.
+
+Supported test definition format is standalone pairs only:
+- `TC-*.runner.md`
+- `TC-*.verify.md`
+- `runner.yml.md`
+- `verifier.yml.md`
+
+Legacy fields `mode` and `execution-model` are not supported.
+
+## Location
+
+```text
+{package}/test/e2e/TS-{AREA}-{NNN}-{slug}/scenario.yml
+```
+
+Example: `ace-lint/test/e2e/TS-LINT-001-lint-pipeline/scenario.yml`
+
+## Schema
+
+### Required Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `test-id` | string | Unique test identifier in format `TS-{AREA}-{NNN}` |
+| `title` | string | Human-readable scenario title |
+| `area` | string | Functional area code |
+| `package` | string | Package name |
+
+### Optional Fields
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `priority` | string | `medium` | Test priority: `high`, `medium`, `low` |
+| `tool-under-test` | string | — | Primary command/tool validated |
+| `sandbox-layout` | object | `{}` | Declared artifact paths and expected outputs |
+| `duration` | string | — | Estimated duration (e.g., `~15min`) |
+| `timeout` | integer | — | Optional per-scenario execution timeout in seconds |
+| `automation-candidate` | boolean | `false` | Whether test is automatable |
+| `tags` | array | `[]` | Scenario tags for filtering with `--tags`/`--exclude-tags` (OR semantics) |
+| `cost-tier` | string | `smoke` | Run profile: `smoke`, `happy-path`, `deep` |
+| `e2e-justification` | string | — | Why E2E is needed |
+| `unit-coverage-reviewed` | array | `[]` | Unit/integration files reviewed |
+| `requires` | object | — | Test prerequisites |
+| `setup` | array | `[]` | Setup directives before execution |
+| `last-verified` | string | — | Last successful verification date |
+| `verified-by` | string | — | Agent that last verified |
+
+## Standalone File Conventions
+
+Scenario directory must contain:
+- `runner.yml.md`
+- `verifier.yml.md`
+- paired `TC-*.runner.md` and `TC-*.verify.md`
+
+Pairing rule:
+- every `TC-XXX.runner.md` must have a matching `TC-XXX.verify.md`
+- every `TC-XXX.verify.md` must have a matching `TC-XXX.runner.md`
+
+Artifact layout conventions:
+- canonical: `results/tc/{NN}/`
+- avoid non-TC-scoped result folders
+
+Canonical summary report fields:
+- `tcs-passed`
+- `tcs-failed`
+- `tcs-total`
+- `failed[].tc`
+
+Role contract:
+- `runner.yml.md` + `TC-*.runner.md` are execution-only.
+- `verifier.yml.md` + `TC-*.verify.md` are verification-only with impact-first checks.
+
+## `requires` Object
+
+```yaml
+requires:
+  tools: [ace-lint, jq]
+  ruby: ">= 3.0"
+```
+
+## `setup` Directives
+
+Available directives:
+- `git-init` — Initialize git repository in sandbox
+- `run:` — Execute a shell command (bash -lc; env vars are re-exported to protect against mise clobbering)
+- `copy-fixtures` — Copy fixtures/ directory into sandbox
+- `write-file:` — Write inline content to a file (`path:` + `content:`)
+- `agent-env:` — Environment variables passed to the runner/verifier agent subprocess (not setup commands)
+- `tmux-session` — Create a detached tmux session
+  - String form: `tmux-session` (uses scenario-based naming)
+  - Hash form: `tmux-session: { name-source: run-id }` (uses unique E2E run ID as session name)
+  - Runner teardown removes the created session after test execution
+
+Example:
+
+```yaml
+setup:
+  - git-init
+  - tmux-session:
+      name-source: run-id
+  - run: "cp $PROJECT_ROOT_PATH/mise.toml mise.toml && mise trust mise.toml"
+  - copy-fixtures
+  - run: git add -A && git commit -m "initial" --quiet
+  - agent-env:
+      PROJECT_ROOT_PATH: "."
+```
+
+Setup rules:
+- Setup is fail-fast. Do not hide setup failures with `|| true`.
+- Setup belongs in `scenario.yml` and fixtures, not in TC runner instructions.
+- If setup fails (for example, missing `mise trust` support), stop scenario execution and report infrastructure failure.
+
+## Complete Example
+
+```yaml
+test-id: TS-LINT-001
+title: Core Lint Pipeline
+area: lint
+package: ace-lint
+priority: high
+duration: ~10min
+cost-tier: smoke
+tags: [smoke, "use-case:lint"]
+e2e-justification: "Validates real subprocess behavior and report file generation"
+unit-coverage-reviewed:
+  - test/molecules/lint_runner_test.rb
+  - test/organisms/lint_orchestrator_test.rb
+tool-under-test: ace-lint
+sandbox-layout:
+  results/tc/01/: "help artifacts"
+requires:
+  tools: [ace-lint, standardrb, jq]
+  ruby: ">= 3.0"
+setup:
+  - git-init
+  - run: "cp $PROJECT_ROOT_PATH/mise.toml mise.toml && mise trust mise.toml"
+  - copy-fixtures
+  - agent-env:
+      PROJECT_ROOT_PATH: "."
+last-verified: 2026-02-24
+verified-by: claude-opus-4
+```
+
+## Tags
+
+The `tags` field enables discovery-time filtering with `--tags` and `--exclude-tags`.
+
+**Naming conventions:**
+- Cost tier is auto-included: `smoke`, `happy-path`, `deep`
+- Use-case tags use the `use-case:{area}` pattern (e.g., `use-case:lint`, `use-case:config`)
+- Custom tags are lowercase kebab-case
+
+**Filtering semantics:**
+- `--tags` uses OR: scenario matches if it has **any** of the specified tags
+- `--exclude-tags` uses OR: scenario is excluded if it has **any** of the specified tags
+- Both filters can be combined; exclude is applied after include
+
+## Directory Structure
+
+```text
+test/e2e/TS-LINT-001-lint-pipeline/
+├── scenario.yml
+├── runner.yml.md
+├── verifier.yml.md
+├── TC-001-help-survey.runner.md
+├── TC-001-help-survey.verify.md
+└── fixtures/
+```

data/handbook/guides/tc-authoring.g.md

@@ -0,0 +1,131 @@
+---
+doc-type: guide
+title: Test Case Authoring Guide
+purpose: Guide for writing standalone TC runner/verifier files for TS-format E2E scenarios
+ace-docs:
+  last-updated: 2026-02-25
+  last-checked: 2026-03-21
+---
+
+# Test Case Authoring Guide
+
+## Overview
+
+TC (Test Case) files are the individual execution units in TS-format E2E scenarios.
+
+Only one authoring format is supported:
+- Standalone runner/verifier pairs:
+  - `TC-*.runner.md`
+  - `TC-*.verify.md`
+
+Inline `.tc.md` and frontmatter `mode` values are no longer supported.
+
+## Canonical Conventions
+
+- Scenario IDs: `TS-<PACKAGE_SHORT>-<NNN>[-slug]`
+- Standalone pair files:
+  - `TC-{NNN}-{slug}.runner.md`
+  - `TC-{NNN}-{slug}.verify.md`
+- Scenario-level config files:
+  - `runner.yml.md`
+  - `verifier.yml.md`
+- TC artifacts write to `results/tc/{NN}/`
+- Summary counters use `tcs-passed`, `tcs-failed`, and `tcs-total`
+
+## File Naming
+
+- `TC-{NNN}` — test case number (e.g., TC-001)
+- `{slug}` — descriptive kebab-case identifier
+
+Examples:
+- `TC-001-help-survey.runner.md`
+- `TC-001-help-survey.verify.md`
+- `TC-002-error-handling.runner.md`
+- `TC-002-error-handling.verify.md`
+
+## Location
+
+TC files are placed in the scenario directory alongside `scenario.yml`:
+
+```text
+{package}/test/e2e/TS-{AREA}-{NNN}-{slug}/
+├── scenario.yml
+├── runner.yml.md
+├── verifier.yml.md
+├── TC-001-{slug}.runner.md
+├── TC-001-{slug}.verify.md
+└── fixtures/
+```
+
+## Runner File Structure (`TC-*.runner.md`)
+
+Required sections:
+- `# Goal N - Title`
+- `## Goal`
+- `## Workspace`
+- `## Constraints`
+
+Example:
+
+```markdown
+# Goal 1 - Generate report
+
+## Goal
+
+Run `ace-lint` and produce report artifacts for a valid file.
+
+## Workspace
+
+- Root: sandbox directory
+- Output: `results/tc/01/`
+
+## Constraints
+
+- Use only sandbox paths
+- Keep evidence under `results/tc/01/`
+- Execute actions only; do not assign PASS/FAIL or final verdicts
+```
+
+## Verifier File Structure (`TC-*.verify.md`)
+
+Required sections:
+- `# Goal N - Title`
+- `## Expectations`
+- `## Verdict`
+
+Example:
+
+```markdown
+# Goal 1 - Generate report
+
+## Expectations
+
+- **Impact Checks**: target sandbox/project state changed as expected
+- **Artifact Checks**: `results/tc/01/report.json` exists and is valid
+- **Debug Fallback**: inspect `stdout`/`stderr`/`*.exit` only when primary checks are inconclusive
+
+## Verdict
+
+Pass only when all expectations are satisfied by on-disk evidence.
+```
+
+## Scenario-Level Configuration
+
+- `tags` in `scenario.yml` control discovery-time filtering via `--tags`/`--exclude-tags`. Tags are not set per-TC; they apply to the entire scenario.
+- `runner.yml.md` bundles execution context for the runner agent (tool paths, sandbox conventions, environment setup).
+- `verifier.yml.md` bundles validation criteria for the independent verifier agent (artifact expectations, verdict rules).
+- TCs execute sequentially within a scenario. The runner agent accumulates context across TCs (e.g., files created in TC-001 are available in TC-002).
+
+## Best Practices
+
+- Keep each TC focused on one coherent behavior path.
+- Ensure goal numbers and TC numbers remain aligned (`TC-001` -> Goal 1).
+- Keep runner files execution-only and verifier files verdict-only.
+- Make verifier expectations deterministic with impact-first ordering.
+- Keep all artifacts under `results/tc/{NN}/` to avoid cross-goal contamination.
+- Record why each scenario remains E2E via `e2e-justification` and `unit-coverage-reviewed` in `scenario.yml`.
+
+## Related
+
+- [scenario.yml Reference](scenario-yml-reference.g.md)
+- [E2E Testing Guide](e2e-testing.g.md)

data/handbook/skills/as-e2e-create/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: as-e2e-create
+description: Create a new E2E test scenario from template
+# bundle: wfi://e2e/create
+# agent: general-purpose
+user-invocable: true
+allowed-tools:
+  - Bash(ace-bundle:*)
+  - Read
+  - Write
+  - Glob
+  - Grep
+argument-hint: <package> <area> [--context <description>]
+last_modified: 2026-01-19
+source: ace-test-runner-e2e
+integration:
+  targets:
+    - claude
+    - codex
+    - gemini
+    - opencode
+    - pi
+  providers: {}
+skill:
+  kind: workflow
+  execution:
+    workflow: wfi://e2e/create
+---
+
+Load and run `ace-bundle wfi://e2e/create` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.

data/handbook/skills/as-e2e-fix/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: as-e2e-fix
+description: Diagnose, fix, and rerun failing E2E tests systematically
+# context: no-fork
+# agent: general-purpose
+user-invocable: true
+allowed-tools:
+  - Bash(ace-task:*)
+  - Bash(ace-bundle:*)
+  - Bash(ace-test:*)
+  - Bash(ace-test-suite:*)
+  - Bash(git:*)
+  - Read
+  - Write
+  - Edit
+  - Grep
+  - Glob
+argument-hint: '[package] [test-id]'
+last_modified: 2026-03-13
+source: ace-test-runner-e2e
+integration:
+  targets:
+    - claude
+    - codex
+    - gemini
+    - opencode
+    - pi
+  providers: {}
+skill:
+  kind: workflow
+  execution:
+    workflow: wfi://e2e/fix
+---
+
+Load and run `ace-bundle wfi://e2e/fix` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.