agent-learning-kit 0.3.0__tar.gz → 0.3.1__tar.gz

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-learning-kit
-Version: 0.3.0
+Version: 0.3.1
 Summary: Unified Future AGI SDK for agent learning workflows.
 Project-URL: Homepage, https://futureagi.com
 Project-URL: Documentation, https://docs.futureagi.com

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-learning-kit"
-version = "0.3.0"
+version = "0.3.1"
 description = "Unified Future AGI SDK for agent learning workflows."
 readme = "README.md"
 requires-python = ">=3.10"

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/src/fi/alk/harness/call_runner.py

@@ -450,7 +450,7 @@ def _read_scenario_document(bundle_dir: Path, scenario_key: str) -> dict[str, An
 
 
 # Edits a call actually plays; everything else is as sealed.
-_EDITABLE_FIELDS = ("background_noise",)
+_EDITABLE_FIELDS = ("background_noise", "max_turns")
 _EDITABLE_PERSONA_FIELDS = (
     "personality",
     "communication_style",

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/src/fi/alk/harness/callback_http_adapter.py

@@ -17,6 +17,9 @@ import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from typing import Any
 
+# Main thread only: with livekit installed this import registers plugins.
+from fi.simulate import AgentInput
+
 
 def _load_callback() -> Any:
     target = os.environ["ALK_CALLBACK_ENTRYPOINT"]
@@ -46,8 +49,6 @@ def _json_body(value: Any) -> dict[str, Any]:
 
 
 def _invoke(payload: dict[str, Any]) -> dict[str, Any]:
-    from fi.simulate import AgentInput
-
     result = CALLBACK(AgentInput.model_validate(payload))
     if inspect.isawaitable(result):
         result = asyncio.run(result)

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/src/fi/alk/harness/scenario_tools.py

@@ -250,6 +250,14 @@ def persona_vocabulary_note() -> str:
     )
 
 
+# A suite is never saved empty, so an emptied list changes nothing on disk until one is submitted.
+_EMPTIED = (
+    "Every scenario is dropped from this session's list, but nothing is saved yet: a suite is never "
+    "saved empty, so the saved scenarios stay until you submit at least one new scenario, which "
+    "then replaces them. Do not tell the person the suite is empty or saved."
+)
+
+
 def write_scenarios(
     scenarios: list[Scenario], destination: Path, catalogue: Catalogue | None = None
 ) -> Path:
@@ -1854,19 +1862,26 @@ def scenario_tools(
 
     @tool(
         "drop_scenario",
-        "Remove a scenario by name, or all of them with name '*'.",
-        schema({"name": str}, ["name"]),
+        "Remove a scenario by name. Removing every scenario takes name '*' with "
+        "everything=true, and only when the person asked to start the suite over.",
+        schema({"name": str, "everything": bool}, ["name"]),
     )
     async def drop_scenario(args: dict[str, Any]) -> dict[str, Any]:
         name = str(args.get("name") or "")
         if name == "*":
+            if args.get("everything") is not True:
+                return _err(
+                    "Dropping every scenario needs everything=true. Do that only when the "
+                    "person asked to start the suite over; otherwise drop scenarios by name."
+                )
             kept.clear()
-            write_scenarios(kept, destination, catalogue)
-            return _ok("all scenarios dropped")
+            return _ok(_EMPTIED)
         before = len(kept)
         kept[:] = [one for one in kept if one.name != name]
         if len(kept) == before:
             return _err(f"no scenario called {name!r}")
+        if not kept:
+            return _ok(_EMPTIED)
         write_scenarios(kept, destination, catalogue)
         return _ok(f"{name} dropped. {len(kept)} left")
 

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/src/fi/alk/harness/simulator_voice.py

@@ -74,7 +74,10 @@ SIMULATOR_INSTRUCTIONS = (
     "write: contractions ('it's', 'I'm'), half sentences, often a word or two ('yeah', 'the second "
     "one'), a bare 'okay' or 'right' to take something in, and now and then an 'uh' or a restart "
     "before a number or a name, as your personality allows. Open with a hello and the gist, not a "
-    "summary of your case. Say codes and email addresses the way people say them. Speech has no "
+    "summary of your case. Say opaque codes, confirmation numbers, booking references and other "
+    "mixed letter-and-digit identifiers one character at a time. For RES-JK90, say 'R E S, J K "
+    "nine zero'; never pronounce letter groups as words. Say email addresses the way people say "
+    "them. Speech has no "
     "dashes, semicolons, brackets or lists.\n"
     "These rules are how a caller behaves unless the scenario describes someone who does not. Rule 14 says which of them the scenario can overrule and which it never can:\n"
     "1. Use ONLY the facts you were given. Never invent an account detail, address, "

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/src/fi/alk/harness/skills/write-scenarios/SKILL.md

@@ -493,7 +493,7 @@ called. Assert on what the world looks like afterwards and on what the caller wa
 | `try_calls` | Runs calls against a **throwaway copy** of the world and shows the state they leave. This is how you work out a solution and what its checks should assert. Nothing you do here is visible to anybody else. |
 | `add_sub_goal` | Adds a named thing this agent can be checked on, with its check in code. |
 | `submit_scenario` | Keeps one scenario, after validation and the three gates. |
-| `drop_scenario` | Removes one by name, or all of them with `*`. |
+| `drop_scenario` | Removes one by name; all of them only with `*` and `everything=true`. A suite is never saved empty: the saved scenarios stay until you submit a new one, which replaces them. |
 | `aim_for` | Sets how many scenarios are wanted. Needed when reopening an existing suite to add more, because the target starts at what is already there. Not for saving a suite nobody asked for. |
 | `save_scenarios` | Finishes the suite. Reports what is off about it as a whole. |
 | `amend_contract`, `add_rule`, `drop_rule`, `fix_tool` | Correct the contract when it is wrong. See the last section. |

agent_learning_kit-0.3.1/tests/harness/test_callback_http_adapter.py

@@ -0,0 +1,73 @@
+import json
+import os
+import socket
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+import pytest
+
+ADAPTER = (
+    Path(__file__).resolve().parents[2] / "src/fi/alk/harness/callback_http_adapter.py"
+)
+
+
+def _free_port() -> int:
+    with socket.socket() as probe:
+        probe.bind(("127.0.0.1", 0))
+        return probe.getsockname()[1]
+
+
+@pytest.fixture
+def adapter(tmp_path):
+    (tmp_path / "chat_agent.py").write_text(
+        "def reply(agent_input):\n"
+        "    return {'content': 'thread ' + agent_input.thread_id}\n",
+        encoding="utf-8",
+    )
+    # Bundles embed the adapter's source and run it from the bundle, not from the package.
+    script = tmp_path / "adapter.py"
+    script.write_text(ADAPTER.read_text(encoding="utf-8"), encoding="utf-8")
+    port = _free_port()
+    process = subprocess.Popen(
+        [sys.executable, str(script)],
+        env={
+            **os.environ,
+            "ALK_CALLBACK_ENTRYPOINT": "chat_agent:reply",
+            "PORT": str(port),
+            "PYTHONPATH": str(tmp_path),
+        },
+        stderr=subprocess.PIPE,
+    )
+    base = f"http://127.0.0.1:{port}"
+    deadline = time.monotonic() + 30
+    while time.monotonic() < deadline:
+        try:
+            urllib.request.urlopen(f"{base}/health", timeout=1)
+            break
+        except OSError:
+            if process.poll() is not None:
+                pytest.fail(process.stderr.read().decode())
+            time.sleep(0.2)
+    yield base
+    process.terminate()
+    process.wait(timeout=10)
+
+
+def test_a_callback_answers_from_the_request_thread(adapter):
+    """The request thread is not the main thread; nothing imported there may require it."""
+    body = json.dumps(
+        {
+            "thread_id": "t1",
+            "messages": [{"role": "user", "content": "hello"}],
+            "new_message": {"role": "user", "content": "hello"},
+        }
+    ).encode()
+    request = urllib.request.Request(
+        f"{adapter}/invoke", data=body, headers={"Content-Type": "application/json"}
+    )
+    with urllib.request.urlopen(request, timeout=30) as response:
+        assert response.status == 200
+        assert json.loads(response.read())["content"] == "thread t1"

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/tests/harness/test_scenario_edits.py

@@ -18,9 +18,14 @@ EDITS = {
     "scenario_edits": {
         "book-ride": {
             "background_noise": "street",
+            "max_turns": 4,
             "tests": "unused by a call",
             "instruction": "ignored",
-            "persona": {"personality": "impatient", "name": "ignored"},
+            "persona": {
+                "personality": "impatient",
+                "languages": ["English", "Hindi"],
+                "name": "ignored",
+            },
         }
     }
 }
@@ -30,7 +35,13 @@ def test_edits_replace_only_what_a_call_plays():
     merged = _with_scenario_edits(SEALED, EDITS, "book-ride")
 
     assert merged["background_noise"] == "street"
-    assert merged["persona"] == {"name": "Asha", "accent": "Indian", "personality": "impatient"}
+    assert merged["persona"] == {
+        "name": "Asha",
+        "accent": "Indian",
+        "personality": "impatient",
+        "languages": ["English", "Hindi"],
+    }
+    assert merged["max_turns"] == 4
     assert merged["tests"] == "books the ride"
     assert merged["instruction"] == "book a ride"
     assert SEALED["background_noise"] == "office"
@@ -47,7 +58,10 @@ def test_a_voice_call_plays_the_edited_place():
 def test_a_chat_caller_is_the_edited_persona():
     merged = _with_scenario_edits(SEALED, EDITS, "book-ride")
 
-    assert _conversation_scenario(merged).persona.personality == "impatient"
+    scenario = _conversation_scenario(merged)
+
+    assert scenario.persona.personality == "impatient"
+    assert scenario.max_turns == 4
 
 
 def test_no_edits_leave_the_sealed_document():

{agent_learning_kit-0.3.0 → agent_learning_kit-0.3.1}/tests/test_harness.py

@@ -7978,3 +7978,34 @@ def test_sub_goals_no_scenario_names_are_the_ones_left_out():
     assert unused_sub_goals(catalogue, kept) == ["test_probe_sub_goal_ast"]
 
 
+def test_dropping_every_scenario_needs_an_explicit_everything(tmp_path):
+    import asyncio
+
+    from mcp.types import CallToolRequestParams
+
+    from fi.alk.harness import scenario_tools as module
+
+    from fi.alk.harness.scenario_tools import accept_scenario
+
+    root, contract, catalogue = _built_environment(tmp_path)
+    saved = []
+    accept_scenario(_delta(), world_root=root, catalogue=catalogue, kept=saved)
+    module.write_scenarios(saved, root, catalogue)
+    server, _kept = module.scenario_tools(contract, root, root, wanted=1)
+    instance = _instance(server)
+
+    async def drop(arguments):
+        handler = _request_handler(instance, "tools/call")
+        answer = await handler.handler(
+            None, CallToolRequestParams(name="drop_scenario", arguments=arguments)
+        )
+        return answer.isError, answer.content[0].text
+
+    refused = asyncio.run(drop({"name": "*"}))
+    by_name = asyncio.run(drop({"name": saved[0].name}))
+    everything = asyncio.run(drop({"name": "*", "everything": True}))
+
+    assert refused[0] and "everything=true" in refused[1]
+    assert not by_name[0] and "nothing is saved yet" in by_name[1]
+    assert not everything[0] and "nothing is saved yet" in everything[1]
+    assert [one.name for one in module.load_scenarios(root)] == [saved[0].name]

agent_learning_kit-0.3.1/tests/test_release_pr_step.py

@@ -0,0 +1,353 @@
+"""The version-bump step, run for real against throwaway git repositories."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import NamedTuple
+
+import pytest
+import yaml
+
+if shutil.which("bash") is None or shutil.which("git") is None:
+    pytest.skip("needs bash and git", allow_module_level=True)
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+RELEASE_WORKFLOW = PROJECT_ROOT / ".github" / "workflows" / "publish-pypi.yml"
+STEP_NAME = "Open the version-bump pull request"
+
+BRANCH = "chore/bump-0.2.4"
+TITLE = "chore(release): bump agent-learning-kit to 0.2.4"
+REFUSAL = "must change one line in pyproject.toml and one in uv.lock"
+ORPHAN = "exists without an open pull request"
+REAL_GIT = shutil.which("git")
+
+PYPROJECT = '[project]\nname = "agent-learning-kit"\nversion = "0.2.3"\n'
+OTHER = 'name = "other-package"\nversion = "1.0.0"\n'
+PROJECT = (
+    'name = "agent-learning-kit"\nversion = "0.2.3"\nsource = { editable = "." }\n'
+)
+LOCK = f"version = 1\n\n[[package]]\n{OTHER}\n[[package]]\n{PROJECT}"
+
+# Stand-ins for the two programs the step calls, so no test reaches the network.
+UV_STANDIN = """\
+import re
+import sys
+from pathlib import Path
+
+VERSION = re.compile(r'^version = "([^"]+)"$', re.MULTILINE)
+
+args = sys.argv[1:]
+if args not in (["version", "--short"], ["version", "--bump", "patch", "--frozen"]):
+    sys.exit(2)
+pyproject = Path("pyproject.toml")
+text = pyproject.read_text(encoding="utf-8")
+current = VERSION.search(text).group(1)
+if args == ["version", "--short"]:
+    print(current)
+else:
+    major, minor, patch = current.split(".")
+    bumped = f"{major}.{minor}.{int(patch) + 1}"
+    pyproject.write_text(VERSION.sub(f'version = "{bumped}"', text), encoding="utf-8")
+"""
+
+GH_STANDIN = """\
+import json
+import os
+import sys
+
+args = sys.argv[1:]
+with open(os.environ["GH_CALLS"], "a", encoding="utf-8") as calls:
+    print(json.dumps(args), file=calls)
+if args[:2] == ["pr", os.environ.get("FAIL_GH", "")]:
+    sys.exit(1)
+if args[:2] == ["pr", "list"]:
+    print(os.environ.get("EXISTING_PR", ""))
+"""
+
+# Passes every call to the real git, except the one subcommand a test asks to fail.
+GIT_STANDIN = f"""\
+import os
+import sys
+
+if sys.argv[1:2] == [os.environ.get("FAIL_GIT", "")]:
+    sys.exit(128)
+os.execv({REAL_GIT!r}, [{REAL_GIT!r}, *sys.argv[1:]])
+"""
+
+
+class Bench(NamedTuple):
+    origin: Path
+    clone: Path
+    calls: Path
+    env: dict[str, str]
+    main: str
+
+
+def _environment(root: Path) -> dict[str, str]:
+    env = {
+        key: value
+        for key, value in os.environ.items()
+        if not key.startswith(("GIT_", "GH_", "GITHUB_"))
+    }
+    env.update(
+        GIT_CONFIG_GLOBAL="/dev/null",
+        GIT_CONFIG_NOSYSTEM="1",
+        HOME=str(root),
+        PATH=os.pathsep.join([str(root / "bin"), env.get("PATH", os.defpath)]),
+        GITHUB_REPOSITORY="future-agi/agent-learning-kit",
+        GH_TOKEN="x",
+        GH_CALLS=str(root / "gh-calls.jsonl"),
+        EXISTING_PR="",
+    )
+    return env
+
+
+def _git(where: Path, env: dict[str, str], *args: str) -> str:
+    done = subprocess.run(
+        ["git", *args],
+        check=False,
+        cwd=where,
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+    assert done.returncode == 0, done.stderr
+    return done.stdout
+
+
+def _install(path: Path, source: str) -> None:
+    path.write_text(f"#!{sys.executable}\n{source}", encoding="utf-8")
+    path.chmod(0o755)
+
+
+def _make_bench(root: Path, lock: str = LOCK) -> Bench:
+    env = _environment(root)
+    origin, clone, bin_dir = root / "origin.git", root / "clone", root / "bin"
+    bin_dir.mkdir()
+    _install(bin_dir / "uv", UV_STANDIN)
+    _install(bin_dir / "gh", GH_STANDIN)
+    _install(bin_dir / "git", GIT_STANDIN)
+    origin.mkdir()
+    _git(origin, env, "init", "--bare", "-b", "main")
+    clone.mkdir()
+    _git(clone, env, "init", "-b", "main")
+    _git(clone, env, "remote", "add", "origin", str(origin))
+    _git(clone, env, "config", "user.email", "dev@example.com")
+    _git(clone, env, "config", "user.name", "Fixture Author")
+    (clone / "pyproject.toml").write_text(PYPROJECT, encoding="utf-8")
+    (clone / "uv.lock").write_text(lock, encoding="utf-8")
+    _git(clone, env, "add", "pyproject.toml", "uv.lock")
+    _git(clone, env, "commit", "-m", "initial")
+    _git(clone, env, "push", "origin", "main")
+    main = _git(clone, env, "rev-parse", "HEAD").strip()
+    return Bench(
+        origin, clone, root / "gh-calls.jsonl", {**env, "GITHUB_SHA": main}, main
+    )
+
+
+@pytest.fixture
+def bench(tmp_path: Path) -> Bench:
+    return _make_bench(tmp_path)
+
+
+def _step_script() -> str:
+    jobs = yaml.safe_load(RELEASE_WORKFLOW.read_text(encoding="utf-8"))["jobs"]
+    steps = [s for s in jobs["release-pr"]["steps"] if s.get("name") == STEP_NAME]
+    assert len(steps) == 1
+    return steps[0]["run"]
+
+
+def _run_step(
+    bench: Bench, existing_pr: str = "", **failing: str
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["bash", "-c", _step_script()],
+        check=False,
+        cwd=bench.clone,
+        env={**bench.env, "EXISTING_PR": existing_pr, **failing},
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+
+
+def _output(result: subprocess.CompletedProcess[str]) -> str:
+    return f"exit {result.returncode}\n{result.stdout}\n{result.stderr}"
+
+
+def _bump_branches(bench: Bench) -> list[str]:
+    refs = _git(
+        bench.origin,
+        bench.env,
+        "for-each-ref",
+        "--format=%(refname:short)",
+        "refs/heads/chore/",
+    )
+    return refs.split()
+
+
+def _tip(bench: Bench, ref: str) -> str:
+    return _git(bench.origin, bench.env, "rev-parse", ref).strip()
+
+
+def _gh_calls(bench: Bench) -> list[list[str]]:
+    if not bench.calls.exists():
+        return []
+    lines = bench.calls.read_text(encoding="utf-8").splitlines()
+    return [json.loads(line) for line in lines]
+
+
+def _gh(bench: Bench, *verb: str) -> list[list[str]]:
+    return [call for call in _gh_calls(bench) if call[: len(verb)] == list(verb)]
+
+
+def _flag(call: list[str], name: str) -> str:
+    return call[call.index(name) + 1]
+
+
+def _leave_a_bump_branch_behind(bench: Bench) -> str:
+    clone, env = bench.clone, bench.env
+    _git(clone, env, "switch", "-c", BRANCH)
+    (clone / "pyproject.toml").write_text(
+        PYPROJECT.replace("0.2.3", "0.2.4"), encoding="utf-8"
+    )
+    lock = (clone / "uv.lock").read_text(encoding="utf-8")
+    (clone / "uv.lock").write_text(
+        lock.replace('version = "0.2.3"', 'version = "0.2.4"'), encoding="utf-8"
+    )
+    _git(clone, env, "commit", "-am", "bump by hand")
+    _git(clone, env, "push", "origin", BRANCH)
+    _git(clone, env, "switch", "main")
+    _git(clone, env, "branch", "-D", BRANCH)
+    return _tip(bench, BRANCH)
+
+
+def _assert_refused(bench: Bench, result: subprocess.CompletedProcess[str]) -> None:
+    assert result.returncode != 0, _output(result)
+    assert REFUSAL in result.stdout + result.stderr, _output(result)
+    assert _bump_branches(bench) == []
+    assert _gh(bench, "pr", "create") == []
+    assert _git(bench.clone, bench.env, "rev-parse", "HEAD").strip() == bench.main
+
+
+def test_opens_a_bump_pull_request_with_two_changed_lines(bench):
+    result = _run_step(bench)
+
+    assert result.returncode == 0, _output(result)
+    assert _bump_branches(bench) == [BRANCH]
+    assert _tip(bench, "main") == bench.main
+    subject, author, email, committer, parents = _git(
+        bench.origin,
+        bench.env,
+        "log",
+        "-1",
+        "--format=%s%n%an%n%ae%n%cn%n%P",
+        BRANCH,
+    ).splitlines()
+    assert subject == TITLE
+    assert (author, email, committer) == (
+        "futureagi-release-bot",
+        "release-bot@futureagi.com",
+        "futureagi-release-bot",
+    )
+    assert parents == bench.main
+    numstat = _git(bench.origin, bench.env, "diff", "--numstat", "main", BRANCH)
+    assert numstat == "1\t1\tpyproject.toml\n1\t1\tuv.lock\n"
+    pyproject = _git(bench.origin, bench.env, "show", f"{BRANCH}:pyproject.toml")
+    lock = _git(bench.origin, bench.env, "show", f"{BRANCH}:uv.lock")
+    assert pyproject == PYPROJECT.replace("0.2.3", "0.2.4")
+    assert lock == LOCK.replace("0.2.3", "0.2.4")
+    assert OTHER in lock
+    (create,) = _gh(bench, "pr", "create")
+    assert _flag(create, "--repo") == "future-agi/agent-learning-kit"
+    assert _flag(create, "--base") == "main"
+    assert _flag(create, "--head") == BRANCH
+    assert _flag(create, "--title") == TITLE
+
+
+def test_does_nothing_when_the_pull_request_is_already_open(bench):
+    result = _run_step(bench, existing_pr="12")
+
+    assert result.returncode == 0, _output(result)
+    assert _bump_branches(bench) == []
+    assert _gh(bench, "pr", "create") == []
+    (lookup,) = _gh(bench, "pr", "list")
+    assert _flag(lookup, "--head") == BRANCH
+    assert _flag(lookup, "--base") == "main"
+    assert _flag(lookup, "--state") == "open"
+    # A fork's pull request with the same branch name must not count as ours.
+    assert _flag(lookup, "--json") == "number,isCrossRepository"
+    assert "select(.isCrossRepository | not)" in _flag(lookup, "--jq")
+
+
+def test_refuses_when_the_branch_exists_without_a_pull_request(bench):
+    left = _leave_a_bump_branch_behind(bench)
+
+    result = _run_step(bench)
+
+    assert result.returncode != 0, _output(result)
+    assert ORPHAN in result.stdout + result.stderr, _output(result)
+    assert _tip(bench, BRANCH) == left
+    assert _gh(bench, "pr", "create") == []
+
+
+def test_ignores_a_branch_that_only_ends_with_the_bump_name(bench):
+    _git(bench.clone, bench.env, "push", "origin", f"main:refs/heads/old/{BRANCH}")
+
+    result = _run_step(bench)
+
+    assert result.returncode == 0, _output(result)
+    assert _bump_branches(bench) == [BRANCH]
+    assert len(_gh(bench, "pr", "create")) == 1
+
+
+@pytest.mark.parametrize(
+    "failing",
+    [{"FAIL_GH": "list"}, {"FAIL_GIT": "ls-remote"}, {"FAIL_GIT": "push"}],
+    ids=["pull-request lookup", "branch lookup", "push"],
+)
+def test_stops_when_a_tool_fails(bench, failing):
+    result = _run_step(bench, **failing)
+
+    assert result.returncode != 0, _output(result)
+    assert _bump_branches(bench) == []
+    assert _gh(bench, "pr", "create") == []
+
+
+def test_a_failed_pull_request_call_is_reported_by_the_next_run(bench):
+    first = _run_step(bench, FAIL_GH="create")
+
+    assert first.returncode != 0, _output(first)
+    assert _bump_branches(bench) == [BRANCH]
+    _git(bench.clone, bench.env, "switch", "main")
+    _git(bench.clone, bench.env, "branch", "-D", BRANCH)
+
+    second = _run_step(bench)
+
+    assert second.returncode != 0, _output(second)
+    assert ORPHAN in second.stdout + second.stderr, _output(second)
+
+
+def test_refuses_when_the_lock_is_out_of_step(tmp_path):
+    bench = _make_bench(tmp_path, LOCK.replace("0.2.3", "0.2.2"))
+
+    _assert_refused(bench, _run_step(bench))
+
+
+def test_refuses_when_the_lock_lists_the_project_twice(tmp_path):
+    bench = _make_bench(tmp_path, f"{LOCK}\n[[package]]\n{PROJECT}")
+
+    _assert_refused(bench, _run_step(bench))
+
+
+def test_refuses_when_the_bump_changes_anything_else(bench):
+    lock = bench.clone / "uv.lock"
+    text = lock.read_text(encoding="utf-8")
+    lock.write_text(text.replace("1.0.0", "1.0.1"), encoding="utf-8")
+
+    _assert_refused(bench, _run_step(bench))