agentfault 0.1.0__tar.gz

agentfault-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,68 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13", "3.14"]
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Install project and development dependencies
+        run: uv sync --locked --extra dev
+
+      - name: Run tests
+        run: uv run --locked pytest
+
+      - name: Lint
+        run: uv run --locked ruff check .
+
+      - name: Type-check
+        run: uv run --locked mypy src/agentfault
+
+      - name: Build distributions
+        run: uv build
+
+      - name: Install wheel in a clean environment and smoke-test it
+        shell: bash
+        run: |
+          python -m venv .venv-wheel-smoke
+          source .venv-wheel-smoke/bin/activate
+          python -m pip install --upgrade pip
+          python -m pip install dist/*.whl "pytest>=8.3,<9"
+          python - <<'PY'
+          from pathlib import Path
+          import agentfault
+
+          installed_from = Path(agentfault.__file__).resolve()
+          assert "site-packages" in str(installed_from), installed_from
+          print(f"Installed package: {installed_from}")
+          PY
+          agentfault --help
+          PYTHONPATH="$GITHUB_WORKSPACE" agentfault run examples.basic_scenario:build_scenario
+          pytest -q

agentfault-0.1.0/.github/workflows/langchain-example.yml

@@ -0,0 +1,40 @@
+name: LangChain example
+
+on:
+  pull_request:
+    paths:
+      - "examples/langchain_benchmark.py"
+      - "tests/examples/test_langchain_benchmark.py"
+      - ".github/workflows/langchain-example.yml"
+      - "README.md"
+      - "docs/custom-adapters.md"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  langchain-example:
+    name: LangChain example (Python 3.12)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install project and integration dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e . "langchain-openai>=0.3,<2" "pytest>=8.3,<9"
+
+      - name: Test adapter without model API calls
+        run: pytest -q tests/examples/test_langchain_benchmark.py
+
+      - name: Check example formatting
+        run: |
+          python -m pip install "ruff>=0.12,<0.13"
+          ruff check examples/langchain_benchmark.py tests/examples/test_langchain_benchmark.py

agentfault-0.1.0/.github/workflows/langgraph-integration.yml

@@ -0,0 +1,38 @@
+name: LangGraph integration
+
+on:
+  pull_request:
+    paths:
+      - "src/agentfault/integrations/langgraph.py"
+      - "examples/langgraph_integration.py"
+      - "tests/examples/test_langgraph_integration.py"
+      - "docs/custom-adapters.md"
+      - ".github/workflows/langgraph-integration.yml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  langgraph-integration:
+    name: LangGraph integration (Python 3.12)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install package and LangGraph integration dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e . "langgraph>=1.0,<2" "pytest>=8.3,<9"
+
+      - name: Run LangGraph integration test
+        run: pytest -q tests/examples/test_langgraph_integration.py
+
+      - name: Run example
+        run: python -m examples.langgraph_integration

agentfault-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,114 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13", "3.14"]
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Install project and development dependencies
+        run: uv sync --locked --extra dev
+
+      - name: Run tests
+        run: uv run --locked pytest
+
+      - name: Lint
+        run: uv run --locked ruff check .
+
+      - name: Type-check
+        run: uv run --locked mypy src/agentfault
+
+  build:
+    name: Build and verify distributions
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Ensure tag matches package version
+        run: |
+          python - <<'PY'
+          import os
+          import tomllib
+          from pathlib import Path
+
+          with Path("pyproject.toml").open("rb") as f:
+              project = tomllib.load(f)["project"]
+
+          expected = f"v{project['version']}"
+          actual = os.environ["GITHUB_REF_NAME"]
+          if actual != expected:
+              raise SystemExit(
+                  f"Release tag {actual!r} does not match package version {expected!r}"
+              )
+          print(f"Preparing {project['name']} {project['version']}")
+          PY
+
+      - name: Build source distribution and wheel
+        run: uv build
+
+      - name: Validate distribution metadata
+        run: uv run --with twine twine check dist/*
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+          if-no-files-found: error
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/agentfault/
+    permissions:
+      id-token: write
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish distributions
+        uses: pypa/gh-action-pypi-publish@release/v1

agentfault-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.env
+.venv/
+__pycache__/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.egg-info/
+*.py[cod]

agentfault-0.1.0/.vscode/settings.json

@@ -0,0 +1,21 @@
+{
+  "[python]": {
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.fixAll.ruff": "always",
+      "source.organizeImports.ruff": "always"
+    },
+    "editor.tabSize": 4,
+    "editor.insertSpaces": true,
+    "editor.detectIndentation": false,
+    "editor.rulers": [88]
+  },
+  "files.trimTrailingWhitespace": true,
+  "files.insertFinalNewline": true,
+  "files.trimFinalNewlines": true,
+  "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
+  "python.analysis.autoImportCompletions": true,
+  "python.analysis.extraPaths": ["./src"],
+  "ruff.importStrategy": "fromEnvironment"
+}

agentfault-0.1.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+Notable changes to Agent Fault are documented here.
+
+This project is in alpha. Until the first release is tagged, changes are collected under `Unreleased`.
+
+## [Unreleased]
+
+### Added
+- A versioned benchmark API with per-case results, assertion evidence, tool-call summaries, and scoring withheld for incomplete runs.
+- The `buying-agent@1.0.0` benchmark suite for safe purchases under price and inventory changes.
+- OpenAI and LangChain examples for the Benchmark API, plus a native LangGraph custom-scenario example.
+- An optional LangChain integration workflow that checks adapter behavior without model API calls.
+- CI validation for Python 3.12, 3.13, and 3.14, including a clean-wheel installation smoke test.
+
+### Changed
+- The README is organized around the two public use cases: reusable benchmarks and custom scenarios, with framework examples for OpenAI, LangChain, and LangGraph.
+- The product's display name is written as **Agent Fault**; the Python import package and distribution identifier remain `agentfault`.
+- The deterministic commerce reference agent rechecks the offer price and inventory after adding an item to the cart.
+
+### Notes
+- APIs are in alpha and may change before the first stable release.
+- The built-in benchmark currently covers buying agents; other categories can use custom scenarios or add versioned suites.
+- The first release version and date will be recorded when a release is actually published.

agentfault-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing to AgentFault
+
+Thanks for contributing. AgentFault is an alpha project focused on testing how tool-using agents behave when the environment changes or tools fail.
+
+## Development setup
+
+Requirements: Python 3.12 or newer and [uv](https://docs.astral.sh/uv/).
+
+From the repository root:
+
+```bash
+uv sync --extra dev
+```
+
+## Checks before opening a pull request
+
+Run the test suite, lint, type-check, and package build:
+
+```bash
+uv run pytest
+uv run ruff check .
+uv run mypy src/agentfault
+uv build
+```
+
+GitHub Actions runs the same checks on Python 3.12, 3.13, and 3.14, then installs the built wheel in a clean environment and smoke-tests the CLI and pytest integration.
+
+## Change guidelines
+
+- Keep agent execution generic. Domain-specific behavior belongs in environments, tools, scenarios, perturbations, or assertions.
+- Prefer small, runnable examples that demonstrate one behavioral contract.
+- When changing scenario behavior, add a test that covers the expected outcome and relevant trajectory evidence.
+- Do not make an intentionally failing example appear to pass. Document expected failure behavior explicitly.
+- Avoid adding runtime dependencies unless they are needed for a clear user-facing capability.
+
+## Pull requests
+
+Use a focused change with a Conventional Commit-style title, explain the motivation and behavioral impact, and note the checks you ran. Do not claim checks passed unless you ran them or CI reports success.

agentfault-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 danishmerani95
+
+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.

agentfault-0.1.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.5
+Name: agentfault
+Version: 0.1.0
+Summary: Agent Fault: open-source stateful reliability testing for AI agents
+Project-URL: Homepage, https://github.com/danishmerani95/AgentFault
+Project-URL: Repository, https://github.com/danishmerani95/AgentFault
+Project-URL: Issues, https://github.com/danishmerani95/AgentFault/issues
+Project-URL: Changelog, https://github.com/danishmerani95/AgentFault/blob/main/CHANGELOG.md
+Author: Agent Fault Contributors
+License: MIT License
+        
+        Copyright (c) 2026 danishmerani95
+        
+        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.
+License-File: LICENSE
+Keywords: agent-reliability,agents,ai,evaluation,failure-injection,reliability,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: openai>=1.0
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: dev
+Requires-Dist: mypy<2,>=1.17; extra == 'dev'
+Requires-Dist: pytest<9,>=8.3; extra == 'dev'
+Requires-Dist: ruff<0.13,>=0.12; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Agent Fault
+
+**Break the world around your agent. Verify its behavior.**
+
+Agent Fault tests tool-using AI agents against changing conditions: a price rises, inventory disappears, an account is suspended, or a tool fails while the agent is working.
+
+It offers two APIs over the same stateful testing engine.
+
+## 1. Benchmark API
+
+**Use it to compare an agent against a reusable, versioned test suite.**
+
+The built-in `buying-agent@1.0.0` benchmark contains five deterministic scenarios covering:
+
+- Buying an eligible offer within budget.
+- Price increases before validation.
+- Inventory disappearing before cart creation.
+- Price increases after an item enters the cart.
+- Inventory disappearing after an item enters the cart.
+
+A benchmark returns a pass percentage, per-case results, failed assertions, and observed tool calls. If any case has an execution error, the headline score is withheld rather than treating an invalid run as a pass or failure.
+
+The API accepts an agent factory that implements AgentFault's `Agent` contract. OpenAI has a built-in adapter; other frameworks can provide an adapter for their tool-call loop.
+
+Run the OpenAI example (requires an OpenAI API key; all tools still use a synthetic test environment):
+
+```bash
+uv sync --extra dev
+export OPENAI_API_KEY=...
+uv run python -m examples.openai_benchmark
+```
+
+The example is in [`examples/openai_benchmark.py`](examples/openai_benchmark.py). It prints a JSON report and can be adapted to use your own prompts, model, and agent.
+
+The [LangChain benchmark example](examples/langchain_benchmark.py) uses LangChain's `ChatOpenAI` and `bind_tools` APIs with the same versioned buying benchmark. AgentFault deliberately executes one tool call at a time, so the model's next decision sees the result and any state change introduced by the scenario. It requires an OpenAI API key and keeps all tool execution in the synthetic test world:
+
+```bash
+export OPENAI_API_KEY=...
+uv run --with "langchain-openai>=0.3,<2" python -m examples.langchain_benchmark
+```
+
+This is a LangChain chat-model adapter, not a wrapper around an arbitrary LangChain `AgentExecutor`; the AgentFault runner owns the tool loop to make stateful interventions deterministic.
+
+## 2. Custom Scenario API
+
+**Use it to test a failure mode specific to your application.**
+
+A scenario defines your agent, isolated environment and tools, an optional perturbation, and assertions about acceptable behavior. Use it for buying, support, research, operations, or any workflow where an agent's actions depend on tool results or changing state.
+
+For an agent that implements `Agent`, compose a `Scenario` and run it with `ScenarioRunner`:
+
+```python
+from agentfault.testing import Scenario, ScenarioRunner
+from agentfault.testing.assertions import MaxPriceAssertion
+from agentfault.testing.perturbations import ChangePrice
+from agentfault.testing.triggers import AfterTool
+from agentfault.tools import ToolRegistry
+
+# Supply these from your application or a test fixture:
+# agent_under_test, test_environment, and the Tool objects.
+tool_registry = ToolRegistry(test_tools)
+
+scenario = Scenario(
+    name="price changes during checkout",
+    agent=agent_under_test,
+    environment=test_environment,
+    perturbations=[
+        (AfterTool("get_offers_for_product"),
+         ChangePrice("offer_sony_1", new_price=179.0)),
+    ],
+    assertions=[MaxPriceAssertion(max_price=150.0)],
+)
+result = ScenarioRunner(tool_registry).run(scenario)
+assert result.passed, [item.message for item in result.assertions if not item.passed]
+```
+
+For a graph that owns its own decision loop, use its integration runner instead of wrapping the entire graph as a generic `Agent`.
+
+Run the LangGraph example (requires LangGraph; no model API key is needed):
+
+```bash
+uv run --with "langgraph>=1.0,<2" python -m examples.langgraph_integration
+```
+
+The [LangGraph example](examples/langgraph_integration.py) uses a real `StateGraph` and `ToolNode`, a scripted decision node, and a fake account/refund world. It shows a custom scenario that suspends an account after lookup and checks that no refund tool is called. The current LangGraph integration supports synchronous `invoke`, sequential calls routed through the configured `ToolNode`; async execution, parallel calls, and other tool paths are not yet supported.
+
+## Use cases
+
+- **Buying agents:** stop unsafe purchases when prices or inventory change.
+- **Support agents:** verify permissions and account state before refunds or account changes.
+- **Search and research agents:** test stale, missing, or contradictory information.
+- **Operations and workflow agents:** inject tool failures and check recovery or safe stopping.
+
+The built-in benchmark currently covers buying. Other roles can be tested today with custom scenarios; additional benchmark packs can use the same versioned suite API.
+
+## Safety and scope
+
+Use fixtures, fake services, or an isolated sandbox. AgentFault does not make production tools safe automatically. Only actions routed through the configured executor/interceptor are recorded and can be perturbed.
+
+Project status: **alpha**. APIs may change. See [custom adapter notes](docs/custom-adapters.md), [contributing](CONTRIBUTING.md), and the [changelog](CHANGELOG.md).

agentfault-0.1.0/README.md

@@ -0,0 +1,100 @@
+# Agent Fault
+
+**Break the world around your agent. Verify its behavior.**
+
+Agent Fault tests tool-using AI agents against changing conditions: a price rises, inventory disappears, an account is suspended, or a tool fails while the agent is working.
+
+It offers two APIs over the same stateful testing engine.
+
+## 1. Benchmark API
+
+**Use it to compare an agent against a reusable, versioned test suite.**
+
+The built-in `buying-agent@1.0.0` benchmark contains five deterministic scenarios covering:
+
+- Buying an eligible offer within budget.
+- Price increases before validation.
+- Inventory disappearing before cart creation.
+- Price increases after an item enters the cart.
+- Inventory disappearing after an item enters the cart.
+
+A benchmark returns a pass percentage, per-case results, failed assertions, and observed tool calls. If any case has an execution error, the headline score is withheld rather than treating an invalid run as a pass or failure.
+
+The API accepts an agent factory that implements AgentFault's `Agent` contract. OpenAI has a built-in adapter; other frameworks can provide an adapter for their tool-call loop.
+
+Run the OpenAI example (requires an OpenAI API key; all tools still use a synthetic test environment):
+
+```bash
+uv sync --extra dev
+export OPENAI_API_KEY=...
+uv run python -m examples.openai_benchmark
+```
+
+The example is in [`examples/openai_benchmark.py`](examples/openai_benchmark.py). It prints a JSON report and can be adapted to use your own prompts, model, and agent.
+
+The [LangChain benchmark example](examples/langchain_benchmark.py) uses LangChain's `ChatOpenAI` and `bind_tools` APIs with the same versioned buying benchmark. AgentFault deliberately executes one tool call at a time, so the model's next decision sees the result and any state change introduced by the scenario. It requires an OpenAI API key and keeps all tool execution in the synthetic test world:
+
+```bash
+export OPENAI_API_KEY=...
+uv run --with "langchain-openai>=0.3,<2" python -m examples.langchain_benchmark
+```
+
+This is a LangChain chat-model adapter, not a wrapper around an arbitrary LangChain `AgentExecutor`; the AgentFault runner owns the tool loop to make stateful interventions deterministic.
+
+## 2. Custom Scenario API
+
+**Use it to test a failure mode specific to your application.**
+
+A scenario defines your agent, isolated environment and tools, an optional perturbation, and assertions about acceptable behavior. Use it for buying, support, research, operations, or any workflow where an agent's actions depend on tool results or changing state.
+
+For an agent that implements `Agent`, compose a `Scenario` and run it with `ScenarioRunner`:
+
+```python
+from agentfault.testing import Scenario, ScenarioRunner
+from agentfault.testing.assertions import MaxPriceAssertion
+from agentfault.testing.perturbations import ChangePrice
+from agentfault.testing.triggers import AfterTool
+from agentfault.tools import ToolRegistry
+
+# Supply these from your application or a test fixture:
+# agent_under_test, test_environment, and the Tool objects.
+tool_registry = ToolRegistry(test_tools)
+
+scenario = Scenario(
+    name="price changes during checkout",
+    agent=agent_under_test,
+    environment=test_environment,
+    perturbations=[
+        (AfterTool("get_offers_for_product"),
+         ChangePrice("offer_sony_1", new_price=179.0)),
+    ],
+    assertions=[MaxPriceAssertion(max_price=150.0)],
+)
+result = ScenarioRunner(tool_registry).run(scenario)
+assert result.passed, [item.message for item in result.assertions if not item.passed]
+```
+
+For a graph that owns its own decision loop, use its integration runner instead of wrapping the entire graph as a generic `Agent`.
+
+Run the LangGraph example (requires LangGraph; no model API key is needed):
+
+```bash
+uv run --with "langgraph>=1.0,<2" python -m examples.langgraph_integration
+```
+
+The [LangGraph example](examples/langgraph_integration.py) uses a real `StateGraph` and `ToolNode`, a scripted decision node, and a fake account/refund world. It shows a custom scenario that suspends an account after lookup and checks that no refund tool is called. The current LangGraph integration supports synchronous `invoke`, sequential calls routed through the configured `ToolNode`; async execution, parallel calls, and other tool paths are not yet supported.
+
+## Use cases
+
+- **Buying agents:** stop unsafe purchases when prices or inventory change.
+- **Support agents:** verify permissions and account state before refunds or account changes.
+- **Search and research agents:** test stale, missing, or contradictory information.
+- **Operations and workflow agents:** inject tool failures and check recovery or safe stopping.
+
+The built-in benchmark currently covers buying. Other roles can be tested today with custom scenarios; additional benchmark packs can use the same versioned suite API.
+
+## Safety and scope
+
+Use fixtures, fake services, or an isolated sandbox. AgentFault does not make production tools safe automatically. Only actions routed through the configured executor/interceptor are recorded and can be perturbed.
+
+Project status: **alpha**. APIs may change. See [custom adapter notes](docs/custom-adapters.md), [contributing](CONTRIBUTING.md), and the [changelog](CHANGELOG.md).

agentfault-0.1.0/RELEASE_CHECKLIST.md

@@ -0,0 +1,30 @@
+# First Release Checklist
+
+Use this checklist before publishing the first public Agent Fault release. Do not publish automatically from this checklist; repository visibility, package identity, version, and destination are deliberate release decisions.
+
+## Project identity and license
+
+- [ ] Confirm the repository is intended to be public before publishing.
+- [x] Display-name decision: use **Agent Fault**. A separate product named AgentFault exists at [agentfault.com](https://agentfault.com/); the similar name remains a potential source of confusion, so the public description should clearly state that this project is an open-source AI-agent reliability testing library.
+- [ ] Verify the PyPI distribution name `agentfault` directly against PyPI before upload; availability has not yet been conclusively established.
+- [x] License decision confirmed: use the MIT License. Keep the `LICENSE` file and package metadata consistent with MIT.
+- [ ] Review ownership and copyright information in `LICENSE`.
+- [ ] Review the README, contributor guide, changelog, and example scenario commands for accuracy.
+
+## Package readiness
+
+- [x] Confirm the version in `pyproject.toml` (`0.1.0`) is the intended first alpha release version.
+- [x] Confirm `uv.lock` is in sync with the project configuration (the current main-branch CI uses `uv sync --locked` successfully).
+- [ ] Run CI on the exact commit intended for release and require all checks to pass.
+- [ ] Build the source distribution and wheel with `uv build`.
+- [ ] Inspect the distributions and metadata before upload; test installing the wheel in a clean environment.
+- [ ] Verify the CLI entry point and pytest plugin work from the installed distribution.
+
+## Publish and announce
+
+- [ ] Decide on and configure the trusted publishing or PyPI credentials workflow.
+- [ ] Publish only after the above checks and owner approval.
+- [ ] Create a version tag (for example, `v0.1.0`) that matches the released package.
+- [ ] Create a GitHub release with notes drawn from `CHANGELOG.md`.
+- [ ] Verify the published package can be installed into a fresh environment and the documented quick start works.
+- [ ] Announce the release with the repository link and clear alpha-status expectations.