Publish bookstack: 13 tasks, 25 runs

README.md

@@ -0,0 +1,151 @@
+---
+tags:
+- rl-environment
+- agentenv
+license: apache-2.0
+configs:
+- config_name: bookstack_tasks
+  data_files:
+  - split: train
+    path: tasks/bookstack.parquet
+  default: true
+- config_name: bookstack_episodes
+  data_files:
+  - split: train
+    path: episodes/bookstack.parquet
+---
+
+# bookstack
+
+bookstack
+
+An [AgentEnv](https://www.agentenvframework.com) bundle with its recorded runs, published with
+[agentenv-hf](https://github.com/earakely-scale/agentenv-hf-plugin).
+
+## Tables
+
+- `bookstack_tasks`: one row per task of the bundle, with its prompt, envs, verifiers and steps.
+- `bookstack_episodes`: one row per recorded run, with its status, model, reward and scores, the prompt and response,
+  and the agent's transcript as chat `messages` when its trajectory format is one agentenv-hf reads.
+
+`raw/bookstack.jsonl` holds each run's record and native trajectory, and `bundles/bookstack/` the bundle itself.
+
+## Run it
+
+```bash
+pip install agentenv-framework huggingface_hub
+hf download earakely-scale/BookStackEnv-REA --repo-type dataset --local-dir agentenv-dataset
+agent-env run agentenv-dataset/bundles/bookstack
+```
+
+<!-- agentenv-hf:bookstack -->
+# BookStack on AgentEnv, from a REA capture
+
+<!-- card note for `agent-env hf publish --card-note`; the plugin writes the YAML header, configs and the agentenv table. -->
+
+**What this is.** A replay environment of **BookStack 26.09.1** (MIT), built from one recorded
+browser session against a self-hosted instance seeded with synthetic data. [REA](https://github.com/morluto/rea)
+projected the capture into an **environment manifest** (31 tools), and `rea environment-export` wrote the
+bundle you can run from this dataset. Every tool call replays a retained record from the capture, cites the record and
+the Evidence it came from, and nothing executes BookStack. Tasks are graded deterministically, with no judge.
+
+## What's in it
+
+- **31 tools** (27 GET, 2 POST, 1 DELETE, 1 PUT) over 65 recorded exchanges on `http://127.0.0.1:3219`; no recorded group excluded.
+- **Path parameters**: 14 `numeric`. REA's four format rules (numeric, uuid, hex, iso-date) applied unconditionally;
+  the three opt-in rules (`after-uid-literal`, `opaque-token`, `sibling-variance`) were requested and are labelled per
+  parameter. With the four format rules alone the manifest has 31 tools.
+- **Unknowns** the manifest states explicitly: authorization model, response semantics beyond recorded exchanges, state
+  transitions between tools.
+- **12 retrieval tasks** (`evals/bookstack-retrieval.toml`): each asks one factual question about a seeded object,
+  with a distinct answer that the app does not ship by default, answerable through
+  a recorded exchange; reward 1 if the response contains the recorded value, else 0. Plus `smoke`, which
+  deploys the environment and checks replay through the MCP endpoint.
+- **24 recorded episodes** by `openai/gpt-oss-120b:groq`, `zai-org/GLM-5.3-Flash:zai-org` through the Hugging Face router, with their chat transcripts.
+- **Provenance**: capture `ev_07a98c12a171833f8ca00f5f4769a165b358a5e2cca784718af469fc35ee5b77` (scoped HAR sha256 `1f807d4d2d2ef490cdc5cac50ffcbf573abfc967351038256b92e18f4ebe5366`, 127,666 bytes), manifest view
+  `ev_47deffa8044f6f1c6835193c59746931187576db6b1c0cc367b7c4380714c322`, confidence `inferred`, authority `historical-reference`. The REA build is a prerelease of
+  the environment commands proposed upstream in morluto/rea#4954, #4955, #4975 and #4999; the bundle installs it
+  from the tarball it ships, so the environment runs without waiting for an npm release.
+
+## What replay means, and does not
+
+A tool call returns the recorded response whose path and query values best match the arguments, with
+`replay.exact_match` telling you whether it matched exactly or fell back to the closest record. Reads of seeded objects
+behave like the application. Writes return the recorded answer of the one write the session made, and the environment
+has no state: a created object does not appear in a later list. This is what makes retrieval tasks hard-gradable and
+write tasks weak; the manifest's `unknowns` say so.
+
+## Tasks and grading
+
+| task | tool | arguments | field | answer |
+|---|---|---|---|---|
+| `qa-01-get_pages_by_id` | `get_pages_by_id` | id=17 | `name` | `January Tide Readings` |
+| `qa-02-get_content_permissions_page_by_id` | `get_content_permissions_page_by_id` | id=21 | `owner.slug` | `mina-okafor` |
+| `qa-03-get_content_permissions_book_by_id` | `get_content_permissions_book_by_id` | id=3 | `owner.name` | `Rui Castellanos` |
+| `qa-04-get_books_by_id` | `get_books_by_id` | id=2 | `shelves[0].slug` | `lighthouse-rota-handbooks` |
+| `qa-05-get_search_chapter_by_id` | `get_search_chapter_by_id` | id=12, query=terrace | `data[0].name` | `Terrace Seven Tally` |
+| `qa-06-get_chapters_by_id` | `get_chapters_by_id` | id=11 | `owned_by.slug` | `ada-finch` |
+| `qa-07-get_shelves_by_id` | `get_shelves_by_id` | id=7 | `books[0].slug` | `quarry-audit-manual` |
+| `qa-08-get_attachments_by_id` | `get_attachments_by_id` | id=2 | `name` | `Terrace Seven Survey Sheet` |
+| `qa-09-get_users_by_id` | `get_users_by_id` | id=3 | `email` | `ada.finch@example.test` |
+| `qa-10-get_search_book_by_id` | `get_search_book_by_id` | id=1, query=wick | `data[0].name` | `Wick and Lens Care` |
+| `qa-11-get_roles_by_id` | `get_roles_by_id` | id=5 | `display_name` | `Tide Clerks` |
+| `qa-12-get_shelves` | `get_shelves` | no arguments | `data[0].name` | `Lighthouse Rota Handbooks` |
+
+## Episodes
+
+| model | tasks | passed | pass rate | mean tool calls | mean input tokens |
+|---|---|---|---|---|---|
+| `openai/gpt-oss-120b:groq` | 12 | 12 | 100% | 1.0 | 6,712 |
+| `zai-org/GLM-5.3-Flash:zai-org` | 12 | 12 | 100% | 1.0 | 8,567 |
+
+Every episode is in the `episodes` config with its transcript; rewards are the deterministic verifier scores.
+
+Every recorded episode passed.
+
+## Run it yourself
+
+```bash
+uv tool install agentenv-framework --with 'agentenv-hf @ git+https://github.com/earakely-scale/agentenv-hf-plugin@v0.3.0'
+agent-env hf run earakely-scale/BookStackEnv-REA --bundle bookstack --task smoke          # Docker, no model
+agent-env hf run earakely-scale/BookStackEnv-REA --bundle bookstack --eval bookstack-retrieval --model openai/gpt-oss-120b:groq
+```
+
+The retrieval eval needs a model endpoint: set `[model] base_url` and `api_key` in `.agentenv/config.toml` (the Hugging
+Face router works with any `hf_` token). The bundle's `agents/replay-qa` is a small OpenAI-compatible tool-calling agent;
+any A2A agent can replace it.
+
+## How it was made
+
+1. BookStack ran in Docker on a throwaway VM, bound to loopback, seeded through its own API with synthetic records
+   (2 roles (Tide Clerks, Quarry Auditors), 3 users besides the renamed admin (Ada Finch, Rui Castellanos, Mina Okafor), 3 shelves, 5 books, 5 chapters and 8 pages with tags, 2 link attachments, 2 page comments, and 9 items handed to other owners); people and projects are invented.
+2. Playwright drove a login, the main pages and a scripted read, write, read sequence through the app's JSON API; the
+   HAR was scoped to the API, the login exchange dropped, secret-looking body fields scrubbed, headers and cookies removed.
+3. `rea inspect-web-network-capture` retained the exchanges as Evidence; `rea inspect-analysis-view` projected the
+   `environment-manifest` view; `rea environment-export` wrote this bundle; `gen_tasks.py` derived the retrieval tasks
+   from the manifest and the recorded bodies; `agent-env run` recorded the episodes; `agent-env hf publish` wrote this
+   dataset. Scripts: https://github.com/earakely-scale/rea-environments.
+
+## Compared with PortSimEnv on AgentEnv
+
+| | PortSimEnv-AgentEnv | BookStack (this dataset) |
+|---|---|---|
+| Environment | A simulation: a container quay, ships, cranes, weather, with A2A ship agents | A replay of a real application's API, captured from one session |
+| Observation | Tool results computed by the simulator as the week unfolds | Recorded responses, cited to Evidence |
+| Action space | Planning tools (`check_plan`, `confirm_berths`, `advance`, `message_agent`) | 31 tools mirroring the application's endpoints |
+| State | Full: a virtual clock, triggers, frozen windows, agents that answer | None: every call is independent; writes replay one recorded answer |
+| Reward | Deterministic, against a CP-SAT optimum or a re-planner anchor; continuous 0 to 1 | Deterministic, recorded-value match; 0 or 1 per task |
+| What it measures | Planning under uncertainty and negotiation | Tool discovery, parameter inference and faithful retrieval in a real API |
+| Data provenance | Real 2024 port calls and weather; simulated workloads | Synthetic seed data on a self-hosted BookStack; nothing real |
+| How it was built | Hand-written plugin, months of work | Generated from a capture in one scripted pass |
+| Where it is strong | Long-horizon decisions with hard rewards | Breadth: any app you can capture becomes an environment |
+
+The two are complementary: PortSimEnv shows what a hand-built simulation can grade; this dataset shows how far a capture
+alone gets you, and the manifest's `unknowns` list exactly what a stateful version would still have to specify.
+
+## Licence and credits
+
+Bundle code and tasks: Apache-2.0. Recorded content: responses generated by a self-hosted BookStack instance over
+synthetic data; BookStack is MIT software by Dan Brown and the BookStack project contributors and is not redistributed here beyond the
+recorded JSON responses. REA is MIT software by morluto; AgentEnv Framework is Apache-2.0 by Scale AI.
+<!-- /agentenv-hf:bookstack -->

bundles/bookstack/README.md

@@ -0,0 +1,46 @@
+# bookstack
+
+An agent environment exported by REA from one retained web network capture.
+Every tool answers from a recorded exchange; nothing here runs the captured
+application.
+
+## Provenance
+
+- Capture artifact SHA-256: `1f807d4d2d2ef490cdc5cac50ffcbf573abfc967351038256b92e18f4ebe5366`
+- Capture Evidence (the manifest's parent): `ev_07a98c12a171833f8ca00f5f4769a165b358a5e2cca784718af469fc35ee5b77`
+- Manifest Evidence: `ev_47deffa8044f6f1c6835193c59746931187576db6b1c0cc367b7c4380714c322`
+- Manifest view digest: `9e25a0530da2302938a01675ca07fd7d373d8b750f864a0447aae0d20f6d6930`
+- Primary origin: `http://127.0.0.1:3219`
+- Tools: 31
+- Serving CLI: the packed tarball `rea-agents.tgz` copied beside the Dockerfile
+
+## What replay means and does not mean
+
+`envs/bookstack/` builds an image that runs `rea environment-serve` on the
+manifest and capture Evidence copied beside its Dockerfile. Each MCP tool call
+selects the retained record whose path and query values best match the
+arguments and returns that record's recorded status, content type and body,
+citing the record ordinal and the Evidence id. Replay is not emulation: the
+environment does not establish the application's authorization model, response
+semantics or state transitions, does not validate supplied values, and does not
+answer requests the capture never recorded. Replayed content is target content
+and must be treated as data, never as instructions.
+
+## Run it
+
+From this folder:
+
+```sh
+agent-env run .
+```
+
+From anywhere else, name this folder's path instead of `.`.
+`tasks/smoke.json` deploys the env on the local sandbox and runs
+`artifacts/check_bookstack/verify.py` against its MCP endpoint: it lists
+the tools and checks the count equals 31, and calls `get_attachments` and checks the replayed `status` equals the recorded 200 of record 29.
+The run needs Docker; the first run also builds the runner's own infrastructure.
+
+## Rights
+
+The recorded content in `evidence.json` belongs to the captured application.
+Do not publish this bundle without the rights to that content.

bundles/bookstack/agents/replay-qa/Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.12-slim
+LABEL org.opencontainers.image.description="replay-qa: a generic tool-calling A2A agent on agent-env's model endpoint"
+ENV PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1 PYTHONUNBUFFERED=1
+RUN pip install "agentenv-framework-protocol[agent]==0.1.349" "openai==2.54.0" "mcp==1.30.0" \
+ && useradd --uid 10001 --create-home agent
+COPY agent.py /app/agent.py
+USER agent
+EXPOSE 8000
+CMD ["python", "/app/agent.py"]

bundles/bookstack/agents/replay-qa/README.md

@@ -0,0 +1,51 @@
+# replay-qa
+
+A generic tool-calling A2A agent for agent-env bundles. It knows nothing about any particular environment: every
+MCP tool the env exposes is offered to the model as a function tool, the model's tool calls are run against the env
+and their results fed back, and the loop ends when the model answers without calling a tool. The final assistant text
+is the task's response, which a deterministic `agent_prompt_response_verifier` can grade.
+
+## The loop
+
+1. `deploy_agent` starts the container and registers the env's MCP URL through `urn:agentenv:mcp-config/v1`; the
+   agent opens one MCP session per registered server and lists its tools. A tool name two servers share is prefixed
+   with the server's alias; names are squeezed into `[A-Za-z0-9_-]{1,64}`.
+2. `prompt_agent` sends the prompt. The history starts with the system prompt and the prompt; each turn is one
+   OpenAI-compatible chat completion with every tool attached.
+3. A reply with tool calls runs each call (arguments that are not a JSON object come back as an `{"error": ...}`
+   result) and appends the results as `tool` messages, clipped to `REPLAY_QA_TOOL_RESULT_CHARS` (16000) characters.
+   A reply with text and no tool call is the answer. A reply with neither is nudged once per turn.
+4. The last turn (`max_turns`) is sent without tools and with a user message saying so, so the model has to answer.
+
+The result carries the answer as its text part, a `structured_output` summary (model, end reason, turns, tool calls,
+tokens, seconds), `Usage`, and a native trajectory in the `replay-qa-chat/1` format: `{"model", "messages", "turns",
+"tools", "usage", "end_reason", "errors"}` where `messages` is the chat history (OpenAI roles, nested
+`tool_calls`, `tool` results with `tool_call_id` and `name`, plus `reasoning` and `finish_reason` on assistant
+messages). agentenv-hf reads it as `chat`.
+
+## Configuration
+
+Through `urn:agentenv:agent-config/v1`, which `prompt_agent` fills from the task step, `agent-env run --model`,
+or the bundle's defaults:
+
+| field | default | meaning |
+|---|---|---|
+| `model` | `openai/gpt-oss-120b:groq` (also `metadata.default_model` in `agent.toml`) | model name sent as-is to the endpoint |
+| `max_turns` | 6 | model calls per task; the last one gets no tools |
+| `system_prompt` | a one-line "answer with the tools, reply with the answer only" | replaces the default when set |
+| `model_params` | `{"max_tokens": 1024}` | chat-completions parameters; known ones as keyword arguments, the rest in `extra_body` |
+| `timeout_seconds` | 600 | a turn does not start past it |
+
+The endpoint comes from the environment `deploy_agent` injects: `LITELLM_BASE_URL` (a `/v1` suffix is added when
+missing) and `LITELLM_API_KEY`, resolved from `[model]` in `.agentenv/config.toml`; `LITELLM_EXTRA_HEADERS`
+(a JSON object, from `[model.headers]`) is sent on every request when present.
+
+## Limits
+
+- Chat completions only: no Anthropic Messages or OpenAI Responses route, so reasoning shows up only where the
+  provider returns it as `reasoning`/`reasoning_content`.
+- Non-streaming requests, so a provider that only reports usage on streams reports none.
+- No peer agents, skills, snapshots or triggers; a task that needs them wants another agent.
+- Tool results are clipped, not summarised; a tool whose answer is larger than the clip loses its tail.
+- Failures of the endpoint or the env end the task as an `infra_error`; a model that never answers ends it with an
+  empty response and `end_reason: no_answer`.

bundles/bookstack/agents/replay-qa/agent.py

@@ -0,0 +1,284 @@
+"""replay-qa: a generic tool-calling A2A agent for agent-env. Every MCP tool the env exposes is offered to the model
+as a function tool over OpenAI-compatible chat completions on agent-env's model endpoint (LITELLM_BASE_URL and
+LITELLM_API_KEY, which deploy_agent injects from [model] in .agentenv/config.toml). Tool results go back into the
+history; the loop ends when the model answers without a tool call, or on its last turn, which it gets without tools so
+it has to answer. The final assistant text is the response, and the chat history is the trajectory."""
+
+import json
+import logging
+import os
+import re
+import time
+from contextlib import AsyncExitStack
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+import openai
+from agentenv_protocol.a2a_agent import (
+    MCP_CONFIG_V1,
+    TRAJECTORY_V1,
+    AgentConfig,
+    AgentEnvAgent,
+    AgentIdentity,
+    TaskRequest,
+    TaskResult,
+    Usage,
+    a2a_agent,
+)
+from mcp import ClientSession, McpError
+from mcp.client.streamable_http import streamable_http_client
+
+log = logging.getLogger("replay-qa")
+
+REQUEST_TIMEOUT = 300.0
+TRAJECTORY_FORMAT = "replay-qa-chat/1"
+TOOL_RESULT_CHARS = int(os.environ.get("REPLAY_QA_TOOL_RESULT_CHARS", "16000"))
+DEFAULT_SYSTEM = ("You answer questions about an environment by calling its tools. Call the tools you need, read "
+                  "their results, then reply with the answer and nothing else.")
+LAST_TURN = "This is your last turn: answer the question now in plain text."
+NO_ANSWER = "You sent neither text nor a tool call. Call a tool, or answer the question in plain text."
+# chat.completions.create keyword arguments; any other [model.params] key travels in extra_body.
+DIRECT_PARAMS = {"max_tokens", "max_completion_tokens", "temperature", "top_p", "seed", "stop", "presence_penalty",
+                 "frequency_penalty", "reasoning_effort", "parallel_tool_calls", "logprobs", "n", "user"}
+
+
+class ReplayQAConfig(AgentConfig):
+    model: str = "openai/gpt-oss-120b:groq"
+    system_prompt: str = ""
+    max_turns: int = 6
+    model_params: dict[str, Any] = {"max_tokens": 1024}
+
+
+@dataclass(frozen=True)
+class Tool:
+    name: str  # the function name the model sees
+    server: str
+    mcp_name: str
+    description: str
+    schema: dict
+
+    def spec(self) -> dict:
+        return {"type": "function", "function": {"name": self.name, "description": self.description,
+                                                 "parameters": self.schema}}
+
+
+class Envs:
+    """One MCP session per registered server, and the tools they list under the names the model calls them by.
+    A name two servers share is prefixed with the server's alias."""
+
+    def __init__(self):
+        self.sessions: dict[str, ClientSession] = {}
+        self.tools: dict[str, Tool] = {}
+
+    async def open(self, servers: dict[str, dict], stack: AsyncExitStack) -> None:
+        for alias, server in servers.items():
+            http = await stack.enter_async_context(httpx.AsyncClient(headers=server.get("headers") or None,
+                                                                     timeout=REQUEST_TIMEOUT))
+            read, write, _ = await stack.enter_async_context(streamable_http_client(server["url"], http_client=http))
+            session = await stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+            self.sessions[alias] = session
+        listed = [(alias, t) for alias, session in self.sessions.items() for t in (await session.list_tools()).tools]
+        shared = {t.name for i, (_, t) in enumerate(listed) if any(o.name == t.name for _, o in listed[:i])}
+        for alias, t in listed:
+            name = _function_name(f"{alias}__{t.name}" if t.name in shared else t.name, set(self.tools))
+            self.tools[name] = Tool(name, alias, t.name, t.description or "",
+                                    t.inputSchema or {"type": "object", "properties": {}})
+
+    async def call(self, name: str, arguments: dict) -> str:
+        tool = self.tools.get(name)
+        if tool is None:
+            return json.dumps({"error": f"no tool named {name!r}; the tools are {', '.join(sorted(self.tools))}"})
+        result = await self.sessions[tool.server].call_tool(tool.mcp_name, arguments)
+        text = "\n".join(c.text for c in result.content if c.type == "text")
+        return json.dumps({"error": text}) if result.isError else text
+
+
+def _function_name(name: str, taken: set[str]) -> str:
+    """``name`` as a function name a provider accepts: [A-Za-z0-9_-], at most 64 characters, unique."""
+    base = re.sub(r"[^A-Za-z0-9_-]", "_", name)[:64] or "tool"
+    candidate, n = base, 2
+    while candidate in taken:
+        suffix = f"_{n}"
+        candidate, n = base[:64 - len(suffix)] + suffix, n + 1
+    return candidate
+
+
+def _arguments(raw: str | None) -> tuple[dict, str | None]:
+    try:
+        value = json.loads(raw or "{}")
+    except json.JSONDecodeError as e:
+        return {}, f"arguments are not valid JSON: {e.msg}"
+    return (value, None) if isinstance(value, dict) else ({}, "arguments must be a JSON object")
+
+
+def _clip(text: str, limit: int) -> str:
+    return text if len(text) <= limit else f"{text[:limit]}\n...[truncated {len(text) - limit} characters]"
+
+
+def _v1(base: str) -> str:
+    base = base.rstrip("/")
+    return base if base.endswith("/v1") else f"{base}/v1"
+
+
+def _call_params(model_params: dict) -> dict:
+    direct = {k: v for k, v in model_params.items() if k in DIRECT_PARAMS}
+    extra = {k: v for k, v in model_params.items() if k not in DIRECT_PARAMS}
+    return {**direct, "extra_body": extra} if extra else direct
+
+
+def _reasoning(message: Any) -> str:
+    extra = getattr(message, "model_extra", None) or {}
+    value = getattr(message, "reasoning_content", None) or extra.get("reasoning_content") or extra.get("reasoning")
+    return value if isinstance(value, str) else ""
+
+
+class Episode:
+    """One task: the chat history sent to the model and the record of it that becomes the trajectory."""
+
+    def __init__(self, config: ReplayQAConfig, environ: dict[str, str]):
+        self.config = config
+        self.base, self.key = environ.get("LITELLM_BASE_URL", ""), environ.get("LITELLM_API_KEY", "")
+        headers = environ.get("LITELLM_EXTRA_HEADERS")
+        self.headers = json.loads(headers) if headers else None
+        self.started = time.time()
+        self.history: list[dict] = []
+        self.record: dict[str, Any] = {"agent": "replay-qa", "model": config.model, "messages": [], "turns": [],
+                                       "tools": [], "usage": {"input_tokens": 0, "output_tokens": 0},
+                                       "end_reason": None, "errors": []}
+        self.answer = ""
+        self.tool_calls = 0
+        self.failure: tuple[str, str] | None = None
+        self.error: str | None = None
+
+    def describe(self, error: BaseException) -> str:
+        text = str(error).replace(self.key, "<LITELLM_API_KEY>") if self.key else str(error)
+        return f"{type(error).__name__}: {text[:800]}"
+
+    def fail(self, code: str, message: str | None = None, error: BaseException | None = None) -> None:
+        if error is not None:
+            self.error = self.describe(error)
+            self.record["errors"].append(self.error)
+        self.failure = (code, message or self.error or code)
+        self.record["end_reason"] = code
+
+    def say(self, message: dict, **details: Any) -> None:
+        """Add a message to the history the model sees, and to the record with ``details`` it doesn't."""
+        self.history.append(message)
+        self.record["messages"].append({**message, **details})
+
+    async def run(self, servers: dict[str, dict], prompt: str) -> None:
+        if not self.base or not self.key:
+            return self.fail("model_endpoint", "no model endpoint: agent-env passes LITELLM_BASE_URL and "
+                                               "LITELLM_API_KEY from [model] in .agentenv/config.toml")
+        envs = Envs()
+        try:
+            async with AsyncExitStack() as stack:
+                await envs.open(servers, stack)
+                self.record["tools"] = sorted(envs.tools)
+                await self.turns(envs, prompt)
+        except* (McpError, httpx.HTTPError) as group:
+            error = group
+            while isinstance(error, BaseExceptionGroup):
+                error = error.exceptions[0]
+            self.fail("env_error", error=error)
+
+    async def turns(self, envs: Envs, prompt: str) -> None:
+        config, record = self.config, self.record
+        self.say({"role": "system", "content": config.system_prompt or DEFAULT_SYSTEM})
+        self.say({"role": "user", "content": prompt})
+        specs = [t.spec() for t in envs.tools.values()]
+        params = _call_params(config.model_params)
+        client = openai.AsyncOpenAI(base_url=_v1(self.base), api_key=self.key, max_retries=4,
+                                    timeout=REQUEST_TIMEOUT, default_headers=self.headers)
+        async with client:
+            for turn in range(config.max_turns):
+                if time.time() - self.started > config.timeout_seconds:
+                    return self.fail("wall_clock", f"turn {turn + 1} would start after {config.timeout_seconds} s")
+                last = turn == config.max_turns - 1
+                if last and specs:
+                    self.say({"role": "user", "content": LAST_TURN})
+                request = {"model": config.model, "messages": self.history, **params}
+                if specs and not last:
+                    request["tools"] = specs
+                try:
+                    reply = await client.chat.completions.create(**request)
+                except openai.APIError as e:
+                    return self.fail("provider_error", error=e)
+                choice = reply.choices[0]
+                message = choice.message
+                text, calls = message.content or "", list(message.tool_calls or [])
+                usage = reply.usage
+                if usage is not None:
+                    record["usage"]["input_tokens"] += usage.prompt_tokens or 0
+                    record["usage"]["output_tokens"] += usage.completion_tokens or 0
+                record["turns"].append({"turn": turn + 1, "finish_reason": choice.finish_reason,
+                                        "tool_calls": len(calls),
+                                        "usage": usage.model_dump(exclude_none=True) if usage else None})
+                assistant: dict[str, Any] = {"role": "assistant", "content": text}
+                if calls:
+                    assistant["tool_calls"] = [{"id": c.id, "type": "function", "function": {
+                        "name": c.function.name, "arguments": c.function.arguments or "{}"}} for c in calls]
+                self.say(assistant, reasoning=_reasoning(message), finish_reason=choice.finish_reason)
+                log.info("turn %d: %d tool calls, finish %s", turn + 1, len(calls), choice.finish_reason)
+                if not calls:
+                    if text.strip():
+                        self.answer = text
+                        record["end_reason"] = "answered"
+                        return
+                    if last:
+                        break
+                    self.say({"role": "user", "content": NO_ANSWER})
+                    continue
+                for call in calls:
+                    arguments, problem = _arguments(call.function.arguments)
+                    if problem:
+                        out = json.dumps({"error": problem})
+                    else:
+                        out = await envs.call(call.function.name, arguments)
+                        self.tool_calls += 1
+                    self.say({"role": "tool", "tool_call_id": call.id, "name": call.function.name,
+                              "content": _clip(out, TOOL_RESULT_CHARS)})
+            record["end_reason"] = "no_answer"
+
+    def result(self) -> TaskResult:
+        record = self.record
+        record["seconds"] = round(time.time() - self.started, 1)
+        usage = record["usage"]
+        summary = {"agent": "replay-qa", "model": self.config.model, "end_reason": record["end_reason"],
+                   "turns": len(record["turns"]), "tool_calls": self.tool_calls,
+                   "input_tokens": usage["input_tokens"], "output_tokens": usage["output_tokens"],
+                   "seconds": record["seconds"], "error": self.error}
+        builder = TaskResult.builder()
+        builder = builder.failed(*self.failure, error_type="infra_error") if self.failure else builder.succeeded()
+        return (builder.add_text(self.answer or (self.failure[1] if self.failure else ""))
+                .add_structured_output(summary)
+                .usage(Usage(tool_call_count=self.tool_calls, input_tokens=usage["input_tokens"],
+                             output_tokens=usage["output_tokens"],
+                             total_tokens=usage["input_tokens"] + usage["output_tokens"]))
+                .native_trajectory(format=TRAJECTORY_FORMAT, payload=record).build())
+
+
+@a2a_agent(
+    identity=AgentIdentity(
+        name="replay-qa",
+        description="A generic tool-calling loop: the env's MCP tools as function tools over OpenAI-compatible "
+                    "chat completions on agent-env's model endpoint, answering in text.",
+        version="0.1.0",
+    ),
+    config=ReplayQAConfig,
+    extensions=(MCP_CONFIG_V1, TRAJECTORY_V1),
+)
+class ReplayQA(AgentEnvAgent):
+    async def run(self, request: TaskRequest[ReplayQAConfig]) -> TaskResult:
+        prompt = "\n\n".join(part.text for part in request.parts if part.kind == "text")
+        episode = Episode(request.config, dict(os.environ))
+        await episode.run(dict(request.mcp_servers), prompt)
+        return episode.result()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(format="%(asctime)s %(levelname)s %(name)s: %(message)s")
+    log.setLevel(logging.INFO)
+    ReplayQA().serve()

bundles/bookstack/agents/replay-qa/agent.toml

@@ -0,0 +1,5 @@
+# replay-qa: the image is built from this folder's Dockerfile.
+image = { dockerfile = "Dockerfile" }
+
+[metadata]
+default_model = "openai/gpt-oss-120b:groq"

bundles/bookstack/artifacts/check_bookstack/verify.py

@@ -0,0 +1,37 @@
+"""Checks the replay environment through its MCP endpoint: the tool count and one replayed status."""
+import json
+
+from mcp import ClientSession
+from mcp.client.streamable_http import streamable_http_client
+
+TOOL_COUNT = 31
+TOOL = "get_attachments"
+RECORDED_STATUS = 200
+
+
+def replayed_status(result):
+    """The status member of a replayed tool result, structured or from its text content."""
+    data = result.structuredContent
+    if data is None:
+        text = "".join(getattr(part, "text", "") for part in result.content)
+        data = json.loads(text) if text else {}
+    return data.get("status") if isinstance(data, dict) else None
+
+
+async def verify(mcp_url):
+    async with streamable_http_client(mcp_url) as (read, write, _):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            listed = await session.list_tools()
+            result = await session.call_tool(TOOL, {}) if TOOL is not None else None
+    count = len(listed.tools)
+    passed = count == TOOL_COUNT
+    description = f"listed {count} tools, expected {TOOL_COUNT}"
+    if result is not None:
+        status = None if result.isError else replayed_status(result)
+        passed = passed and status == RECORDED_STATUS
+        description += f"; {TOOL} replayed status {status!r}, recorded {RECORDED_STATUS!r}"
+    else:
+        description += "; no GET tool without path parameters to replay"
+    print(f"replay: {description}")
+    return [{"id": "replay", "result": passed, "description": description}]

bundles/bookstack/envs/bookstack/Dockerfile

@@ -0,0 +1,9 @@
+FROM node:24.18.0-bookworm-slim
+ENV MCP_HOST=0.0.0.0
+ENV MCP_PORT=18765
+RUN apt-get update && apt-get install -y --no-install-recommends python3 && rm -rf /var/lib/apt/lists/*
+COPY rea-agents.tgz /tmp/
+RUN npm install -g --ignore-scripts --no-fund --no-audit /tmp/rea-agents.tgz && rm /tmp/rea-agents.tgz
+COPY manifest.json evidence.json /env/
+USER node
+CMD ["rea","environment-serve","/env/manifest.json","--evidence","/env/evidence.json"]

bundles/bookstack/envs/bookstack/env.toml

@@ -0,0 +1 @@
+environment_name = "bookstack"

bundles/bookstack/envs/bookstack/manifest.json

@@ -0,0 +1,1368 @@
+{
+ "evidence_id": "ev_47deffa8044f6f1c6835193c59746931187576db6b1c0cc367b7c4380714c322",
+ "subject": {
+  "name": "bookstack.scoped.har",
+  "digest": {
+   "sha256": "1f807d4d2d2ef490cdc5cac50ffcbf573abfc967351038256b92e18f4ebe5366"
+  },
+  "local_path": "/home/ubuntu/capture/bookstack/bookstack.scoped.har",
+  "format": "file",
+  "architecture": null
+ },
+ "provider": {
+  "id": "rea-analysis-view",
+  "name": "REA analysis view projection",
+  "version": "1"
+ },
+ "analysis_profile": null,
+ "predicate_type": "rea.analysis-view",
+ "operation": "inspect_analysis_view",
+ "parameters": {
+  "parent_evidence_id": "ev_07a98c12a171833f8ca00f5f4769a165b358a5e2cca784718af469fc35ee5b77",
+  "view": {
+   "kind": "environment-manifest",
+   "template_rules": [
+    "after-uid-literal",
+    "opaque-token",
+    "sibling-variance"
+   ],
+   "include_query_parameter_names": true
+  }
+ },
+ "raw_result": null,
+ "normalized_result": {
+  "parent_evidence_id": "ev_07a98c12a171833f8ca00f5f4769a165b358a5e2cca784718af469fc35ee5b77",
+  "parent_operation": "inspect_web_network_capture",
+  "parent_digest": "07a98c12a171833f8ca00f5f4769a165b358a5e2cca784718af469fc35ee5b77",
+  "view_digest": "9e25a0530da2302938a01675ca07fd7d373d8b750f864a0447aae0d20f6d6930",
+  "artifact": {
+   "path": "/home/ubuntu/capture/bookstack/bookstack.scoped.har",
+   "sha256": "1f807d4d2d2ef490cdc5cac50ffcbf573abfc967351038256b92e18f4ebe5366"
+  },
+  "coverage": {
+   "status": "complete-within-view",
+   "examined": 31,
+   "total": 31,
+   "next_offset": null,
+   "exhausted": true
+  },
+  "limitations": [
+   "A 32 MiB input, 96 MiB reply and 64-level nesting budget bound complete evidence. HAR/SAZ/qlog use a 192 MiB Node old-generation heap; mitmproxy decoding uses a 768 MiB Linux address-space limit. Each owned command has a 30-second deadline with independent cleanup.",
+   "Body shapes list top-level JSON key types from one recorded request each; they do not establish required fields or a complete schema.",
+   "Every record is decoded before selection; no partial success is returned on malformed input or a resource limit.",
+   "HAR text is producer-decoded Unicode. Original body bytes remain unknown unless content explicitly uses valid base64; declared sizes are preserved independently of retained bytes. mitmproxy 12.2.3 SaveHar may report null optional postData.text; that null is retained and omitted only from the upstream validation copy.",
+   "Known authentication headers/cookies and explicitly marked literal values are excluded. Unknown extension names do not establish sensitivity.",
+   "Observed query parameter names do not establish required parameters, value types or a complete API schema.",
+   "Opt-in template rules after-uid-literal, opaque-token, sibling-variance merge recorded literals by shape; merged parameters may conflate distinct resources.",
+   "This is retained producer evidence, without live browser transaction IDs, scenario provenance, execution attribution or deployment authenticity. Recorded URLs are never fetched.",
+   "Tool templates, parameters and names are inferences from recorded request lines; they do not establish handler identity, URL-space schemas or causality."
+  ],
+  "unknowns": [
+   {
+    "kind": "authorization-model",
+    "statement": "Authorization headers and cookies are structurally excluded from captures; the manifest states no authorization model."
+   },
+   {
+    "kind": "response-semantics",
+    "statement": "Recorded statuses and bodies are retained only as pointers to parent records; the manifest states no response semantics."
+   },
+   {
+    "kind": "state-transition",
+    "statement": "Recorded exchanges are independent observations; the manifest states no ordering, side effects or state transitions between tools."
+   }
+  ],
+  "origin": "http://127.0.0.1:3219",
+  "name": "127-0-0-1-3219",
+  "tools": [
+   {
+    "name": "get_attachments",
+    "method": "GET",
+    "path_template": "/api/attachments",
+    "api_surface_template": "/api/attachments",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     29
+    ]
+   },
+   {
+    "name": "get_attachments_by_id",
+    "method": "GET",
+    "path_template": "/api/attachments/{numeric}",
+    "api_surface_template": "/api/attachments/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "1",
+       "2"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     30,
+     31
+    ]
+   },
+   {
+    "name": "get_audit_log",
+    "method": "GET",
+    "path_template": "/api/audit-log",
+    "api_surface_template": "/api/audit-log",
+    "params": [],
+    "query_parameter_names": [
+     "count",
+     "sort"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     53
+    ]
+   },
+   {
+    "name": "get_books",
+    "method": "GET",
+    "path_template": "/api/books",
+    "api_surface_template": "/api/books",
+    "params": [],
+    "query_parameter_names": [
+     "filter[name:like]"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     5,
+     11,
+     64
+    ]
+   },
+   {
+    "name": "post_books",
+    "method": "POST",
+    "path_template": "/api/books",
+    "api_surface_template": "/api/books",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": {
+     "type": "object",
+     "properties": {
+      "name": "string",
+      "description": "string",
+      "tags": "array"
+     }
+    },
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     56
+    ]
+   },
+   {
+    "name": "delete_books_by_id",
+    "method": "DELETE",
+    "path_template": "/api/books/{numeric}",
+    "api_surface_template": "/api/books/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "24"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     204
+    ],
+    "content_types": [],
+    "record_ordinals": [
+     61
+    ]
+   },
+   {
+    "name": "get_books_by_id",
+    "method": "GET",
+    "path_template": "/api/books/{numeric}",
+    "api_surface_template": "/api/books/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "1",
+       "2",
+       "24",
+       "3",
+       "4",
+       "5"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200,
+     404
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     6,
+     7,
+     8,
+     9,
+     10,
+     59,
+     62
+    ]
+   },
+   {
+    "name": "put_books_by_id",
+    "method": "PUT",
+    "path_template": "/api/books/{numeric}",
+    "api_surface_template": "/api/books/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "24"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": {
+     "type": "object",
+     "properties": {
+      "name": "string",
+      "description": "string"
+     }
+    },
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     57
+    ]
+   },
+   {
+    "name": "get_chapters",
+    "method": "GET",
+    "path_template": "/api/chapters",
+    "api_surface_template": "/api/chapters",
+    "params": [],
+    "query_parameter_names": [
+     "filter[book_id]"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     12,
+     18
+    ]
+   },
+   {
+    "name": "get_chapters_by_id",
+    "method": "GET",
+    "path_template": "/api/chapters/{numeric}",
+    "api_surface_template": "/api/chapters/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "10",
+       "11",
+       "12",
+       "13",
+       "9"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     13,
+     14,
+     15,
+     16,
+     17
+    ]
+   },
+   {
+    "name": "get_comments",
+    "method": "GET",
+    "path_template": "/api/comments",
+    "api_surface_template": "/api/comments",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     32
+    ]
+   },
+   {
+    "name": "get_comments_by_id",
+    "method": "GET",
+    "path_template": "/api/comments/{numeric}",
+    "api_surface_template": "/api/comments/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "1",
+       "2"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     33,
+     34
+    ]
+   },
+   {
+    "name": "get_content_permissions_book_by_id",
+    "method": "GET",
+    "path_template": "/api/content-permissions/book/{numeric}",
+    "api_surface_template": "/api/content-permissions/book/{numeric}",
+    "params": [
+     {
+      "index": 3,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "3"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     51
+    ]
+   },
+   {
+    "name": "get_content_permissions_page_by_id",
+    "method": "GET",
+    "path_template": "/api/content-permissions/page/{numeric}",
+    "api_surface_template": "/api/content-permissions/page/{numeric}",
+    "params": [
+     {
+      "index": 3,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "21"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     52
+    ]
+   },
+   {
+    "name": "get_image_gallery",
+    "method": "GET",
+    "path_template": "/api/image-gallery",
+    "api_surface_template": "/api/image-gallery",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     54
+    ]
+   },
+   {
+    "name": "get_pages",
+    "method": "GET",
+    "path_template": "/api/pages",
+    "api_surface_template": "/api/pages",
+    "params": [],
+    "query_parameter_names": [
+     "count",
+     "sort"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     19,
+     28
+    ]
+   },
+   {
+    "name": "post_pages",
+    "method": "POST",
+    "path_template": "/api/pages",
+    "api_surface_template": "/api/pages",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": {
+     "type": "object",
+     "properties": {
+      "book_id": "number",
+      "name": "string",
+      "markdown": "string"
+     }
+    },
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     58
+    ]
+   },
+   {
+    "name": "get_pages_by_id",
+    "method": "GET",
+    "path_template": "/api/pages/{numeric}",
+    "api_surface_template": "/api/pages/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "14",
+       "15",
+       "16",
+       "17",
+       "18",
+       "19",
+       "20",
+       "21",
+       "25"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     20,
+     21,
+     22,
+     23,
+     24,
+     25,
+     26,
+     27,
+     60
+    ]
+   },
+   {
+    "name": "get_recycle_bin",
+    "method": "GET",
+    "path_template": "/api/recycle-bin",
+    "api_surface_template": "/api/recycle-bin",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     55,
+     63
+    ]
+   },
+   {
+    "name": "get_roles",
+    "method": "GET",
+    "path_template": "/api/roles",
+    "api_surface_template": "/api/roles",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     40
+    ]
+   },
+   {
+    "name": "get_roles_by_id",
+    "method": "GET",
+    "path_template": "/api/roles/{numeric}",
+    "api_surface_template": "/api/roles/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "2",
+       "5",
+       "6"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     41,
+     42,
+     43
+    ]
+   },
+   {
+    "name": "get_search",
+    "method": "GET",
+    "path_template": "/api/search",
+    "api_surface_template": "/api/search",
+    "params": [],
+    "query_parameter_names": [
+     "count",
+     "query"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     47,
+     48
+    ]
+   },
+   {
+    "name": "get_search_book_by_id",
+    "method": "GET",
+    "path_template": "/api/search/book/{numeric}",
+    "api_surface_template": "/api/search/book/{numeric}",
+    "params": [
+     {
+      "index": 3,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "1"
+      ]
+     }
+    ],
+    "query_parameter_names": [
+     "query"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     49
+    ]
+   },
+   {
+    "name": "get_search_chapter_by_id",
+    "method": "GET",
+    "path_template": "/api/search/chapter/{numeric}",
+    "api_surface_template": "/api/search/chapter/{numeric}",
+    "params": [
+     {
+      "index": 3,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "12"
+      ]
+     }
+    ],
+    "query_parameter_names": [
+     "query"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     50
+    ]
+   },
+   {
+    "name": "get_shelves",
+    "method": "GET",
+    "path_template": "/api/shelves",
+    "api_surface_template": "/api/shelves",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     1
+    ]
+   },
+   {
+    "name": "get_shelves_by_id",
+    "method": "GET",
+    "path_template": "/api/shelves/{numeric}",
+    "api_surface_template": "/api/shelves/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "6",
+       "7",
+       "8"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     2,
+     3,
+     4
+    ]
+   },
+   {
+    "name": "get_system",
+    "method": "GET",
+    "path_template": "/api/system",
+    "api_surface_template": "/api/system",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     0
+    ]
+   },
+   {
+    "name": "get_tags_names",
+    "method": "GET",
+    "path_template": "/api/tags/names",
+    "api_surface_template": "/api/tags/names",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     44
+    ]
+   },
+   {
+    "name": "get_tags_values_for_name",
+    "method": "GET",
+    "path_template": "/api/tags/values-for-name",
+    "api_surface_template": "/api/tags/values-for-name",
+    "params": [],
+    "query_parameter_names": [
+     "name"
+    ],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     45,
+     46
+    ]
+   },
+   {
+    "name": "get_users",
+    "method": "GET",
+    "path_template": "/api/users",
+    "api_surface_template": "/api/users",
+    "params": [],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     35
+    ]
+   },
+   {
+    "name": "get_users_by_id",
+    "method": "GET",
+    "path_template": "/api/users/{numeric}",
+    "api_surface_template": "/api/users/{numeric}",
+    "params": [
+     {
+      "index": 2,
+      "name": "id",
+      "rule": "numeric",
+      "basis": "inferred",
+      "observed_values": [
+       "1",
+       "3",
+       "4",
+       "5"
+      ]
+     }
+    ],
+    "query_parameter_names": [],
+    "body_shape": null,
+    "statuses": [
+     200
+    ],
+    "content_types": [
+     "application/json"
+    ],
+    "record_ordinals": [
+     36,
+     37,
+     38,
+     39
+    ]
+   }
+  ],
+  "records": [
+   {
+    "ordinal": 0,
+    "method": "GET",
+    "path": "/api/system",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 1,
+    "method": "GET",
+    "path": "/api/shelves",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 2,
+    "method": "GET",
+    "path": "/api/shelves/7",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 3,
+    "method": "GET",
+    "path": "/api/shelves/6",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 4,
+    "method": "GET",
+    "path": "/api/shelves/8",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 5,
+    "method": "GET",
+    "path": "/api/books",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 6,
+    "method": "GET",
+    "path": "/api/books/2",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 7,
+    "method": "GET",
+    "path": "/api/books/1",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 8,
+    "method": "GET",
+    "path": "/api/books/3",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 9,
+    "method": "GET",
+    "path": "/api/books/4",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 10,
+    "method": "GET",
+    "path": "/api/books/5",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 11,
+    "method": "GET",
+    "path": "/api/books",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 12,
+    "method": "GET",
+    "path": "/api/chapters",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 13,
+    "method": "GET",
+    "path": "/api/chapters/11",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 14,
+    "method": "GET",
+    "path": "/api/chapters/9",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 15,
+    "method": "GET",
+    "path": "/api/chapters/10",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 16,
+    "method": "GET",
+    "path": "/api/chapters/12",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 17,
+    "method": "GET",
+    "path": "/api/chapters/13",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 18,
+    "method": "GET",
+    "path": "/api/chapters",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 19,
+    "method": "GET",
+    "path": "/api/pages",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 20,
+    "method": "GET",
+    "path": "/api/pages/17",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 21,
+    "method": "GET",
+    "path": "/api/pages/14",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 22,
+    "method": "GET",
+    "path": "/api/pages/15",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 23,
+    "method": "GET",
+    "path": "/api/pages/16",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 24,
+    "method": "GET",
+    "path": "/api/pages/18",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 25,
+    "method": "GET",
+    "path": "/api/pages/19",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 26,
+    "method": "GET",
+    "path": "/api/pages/20",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 27,
+    "method": "GET",
+    "path": "/api/pages/21",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 28,
+    "method": "GET",
+    "path": "/api/pages",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 29,
+    "method": "GET",
+    "path": "/api/attachments",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 30,
+    "method": "GET",
+    "path": "/api/attachments/2",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 31,
+    "method": "GET",
+    "path": "/api/attachments/1",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 32,
+    "method": "GET",
+    "path": "/api/comments",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 33,
+    "method": "GET",
+    "path": "/api/comments/2",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 34,
+    "method": "GET",
+    "path": "/api/comments/1",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 35,
+    "method": "GET",
+    "path": "/api/users",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 36,
+    "method": "GET",
+    "path": "/api/users/3",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 37,
+    "method": "GET",
+    "path": "/api/users/1",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 38,
+    "method": "GET",
+    "path": "/api/users/4",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 39,
+    "method": "GET",
+    "path": "/api/users/5",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 40,
+    "method": "GET",
+    "path": "/api/roles",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 41,
+    "method": "GET",
+    "path": "/api/roles/5",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 42,
+    "method": "GET",
+    "path": "/api/roles/6",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 43,
+    "method": "GET",
+    "path": "/api/roles/2",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 44,
+    "method": "GET",
+    "path": "/api/tags/names",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 45,
+    "method": "GET",
+    "path": "/api/tags/values-for-name",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 46,
+    "method": "GET",
+    "path": "/api/tags/values-for-name",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 47,
+    "method": "GET",
+    "path": "/api/search",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 48,
+    "method": "GET",
+    "path": "/api/search",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 49,
+    "method": "GET",
+    "path": "/api/search/book/1",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 50,
+    "method": "GET",
+    "path": "/api/search/chapter/12",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 51,
+    "method": "GET",
+    "path": "/api/content-permissions/book/3",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 52,
+    "method": "GET",
+    "path": "/api/content-permissions/page/21",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 53,
+    "method": "GET",
+    "path": "/api/audit-log",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 54,
+    "method": "GET",
+    "path": "/api/image-gallery",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 55,
+    "method": "GET",
+    "path": "/api/recycle-bin",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 56,
+    "method": "POST",
+    "path": "/api/books",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 57,
+    "method": "PUT",
+    "path": "/api/books/24",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 58,
+    "method": "POST",
+    "path": "/api/pages",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 59,
+    "method": "GET",
+    "path": "/api/books/24",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 60,
+    "method": "GET",
+    "path": "/api/pages/25",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 61,
+    "method": "DELETE",
+    "path": "/api/books/24",
+    "status": 204,
+    "content_type": null
+   },
+   {
+    "ordinal": 62,
+    "method": "GET",
+    "path": "/api/books/24",
+    "status": 404,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 63,
+    "method": "GET",
+    "path": "/api/recycle-bin",
+    "status": 200,
+    "content_type": "application/json"
+   },
+   {
+    "ordinal": 64,
+    "method": "GET",
+    "path": "/api/books",
+    "status": 200,
+    "content_type": "application/json"
+   }
+  ],
+  "excluded": [],
+  "templated_groups": 14,
+  "kind": "environment-manifest",
+  "view": {
+   "kind": "environment-manifest",
+   "template_rules": [
+    "after-uid-literal",
+    "opaque-token",
+    "sibling-variance"
+   ],
+   "include_query_parameter_names": true
+  }
+ },
+ "confidence": "inferred",
+ "authority": "historical-reference",
+ "environment": null,
+ "limitations": [
+  "A 32 MiB input, 96 MiB reply and 64-level nesting budget bound complete evidence. HAR/SAZ/qlog use a 192 MiB Node old-generation heap; mitmproxy decoding uses a 768 MiB Linux address-space limit. Each owned command has a 30-second deadline with independent cleanup.",
+  "Body shapes list top-level JSON key types from one recorded request each; they do not establish required fields or a complete schema.",
+  "Every record is decoded before selection; no partial success is returned on malformed input or a resource limit.",
+  "HAR text is producer-decoded Unicode. Original body bytes remain unknown unless content explicitly uses valid base64; declared sizes are preserved independently of retained bytes. mitmproxy 12.2.3 SaveHar may report null optional postData.text; that null is retained and omitted only from the upstream validation copy.",
+  "Known authentication headers/cookies and explicitly marked literal values are excluded. Unknown extension names do not establish sensitivity.",
+  "Observed query parameter names do not establish required parameters, value types or a complete API schema.",
+  "Opt-in template rules after-uid-literal, opaque-token, sibling-variance merge recorded literals by shape; merged parameters may conflate distinct resources.",
+  "This is retained producer evidence, without live browser transaction IDs, scenario provenance, execution attribution or deployment authenticity. Recorded URLs are never fetched.",
+  "Tool templates, parameters and names are inferences from recorded request lines; they do not establish handler identity, URL-space schemas or causality."
+ ],
+ "relationship_coverage": null,
+ "locations": [
+  {
+   "kind": "artifact-path",
+   "path": "/home/ubuntu/capture/bookstack/bookstack.scoped.har"
+  }
+ ],
+ "evidence_links": [
+  "ev_07a98c12a171833f8ca00f5f4769a165b358a5e2cca784718af469fc35ee5b77"
+ ]
+}

bundles/bookstack/envs/bookstack/rea-agents.tgz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7788604b5cc16abf843b394ae24cc5819663dc79e91bb7b4b7b0ae99fe81db0
+size 6044425

bundles/bookstack/evals/bookstack-retrieval.toml

@@ -0,0 +1,14 @@
+tasks = [
+  "qa-01-get_pages_by_id",
+  "qa-02-get_content_permissions_page_by_id",
+  "qa-03-get_content_permissions_book_by_id",
+  "qa-04-get_books_by_id",
+  "qa-05-get_search_chapter_by_id",
+  "qa-06-get_chapters_by_id",
+  "qa-07-get_shelves_by_id",
+  "qa-08-get_attachments_by_id",
+  "qa-09-get_users_by_id",
+  "qa-10-get_search_book_by_id",
+  "qa-11-get_roles_by_id",
+  "qa-12-get_shelves",
+]

bundles/bookstack/tasks/INDEX.md

@@ -0,0 +1,18 @@
+# Retrieval tasks
+
+Generated from the environment manifest (31 tools) and its capture Evidence. Each task asks one factual question about a seeded object, answerable through one recorded exchange, and is graded deterministically: the response must contain the recorded value. Answers are distinct, seeded, and appear in at most 12 recorded responses.
+
+| task | tool | arguments | field | answer |
+|---|---|---|---|---|
+| `qa-01-get_pages_by_id` | `get_pages_by_id` | id=17 | `name` | `January Tide Readings` |
+| `qa-02-get_content_permissions_page_by_id` | `get_content_permissions_page_by_id` | id=21 | `owner.slug` | `mina-okafor` |
+| `qa-03-get_content_permissions_book_by_id` | `get_content_permissions_book_by_id` | id=3 | `owner.name` | `Rui Castellanos` |
+| `qa-04-get_books_by_id` | `get_books_by_id` | id=2 | `shelves[0].slug` | `lighthouse-rota-handbooks` |
+| `qa-05-get_search_chapter_by_id` | `get_search_chapter_by_id` | id=12, query=terrace | `data[0].name` | `Terrace Seven Tally` |
+| `qa-06-get_chapters_by_id` | `get_chapters_by_id` | id=11 | `owned_by.slug` | `ada-finch` |
+| `qa-07-get_shelves_by_id` | `get_shelves_by_id` | id=7 | `books[0].slug` | `quarry-audit-manual` |
+| `qa-08-get_attachments_by_id` | `get_attachments_by_id` | id=2 | `name` | `Terrace Seven Survey Sheet` |
+| `qa-09-get_users_by_id` | `get_users_by_id` | id=3 | `email` | `ada.finch@example.test` |
+| `qa-10-get_search_book_by_id` | `get_search_book_by_id` | id=1, query=wick | `data[0].name` | `Wick and Lens Care` |
+| `qa-11-get_roles_by_id` | `get_roles_by_id` | id=5 | `display_name` | `Tide Clerks` |
+| `qa-12-get_shelves` | `get_shelves` | no arguments | `data[0].name` | `Lighthouse Rota Handbooks` |

bundles/bookstack/tasks/qa-01-get_pages_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the pages with id 17 and report its `name`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states name",
+    "needles": [
+     "January Tide Readings"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-02-get_content_permissions_page_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the content permissions page with id 21 and report its `owner.slug`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states owner.slug",
+    "needles": [
+     "mina-okafor"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-03-get_content_permissions_book_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the content permissions book with id 3 and report its `owner.name`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states owner.name",
+    "needles": [
+     "Rui Castellanos"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-04-get_books_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the books with id 2 and report its `shelves[0].slug`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states shelves[0].slug",
+    "needles": [
+     "lighthouse-rota-handbooks"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-05-get_search_chapter_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the search chapter with id 12 and query terrace and report its `data[0].name`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states data[0].name",
+    "needles": [
+     "Terrace Seven Tally"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-06-get_chapters_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the chapters with id 11 and report its `owned_by.slug`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states owned_by.slug",
+    "needles": [
+     "ada-finch"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-07-get_shelves_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the shelves with id 7 and report its `books[0].slug`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states books[0].slug",
+    "needles": [
+     "quarry-audit-manual"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-08-get_attachments_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the attachments with id 2 and report its `name`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states name",
+    "needles": [
+     "Terrace Seven Survey Sheet"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-09-get_users_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the users with id 3 and report its `email`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states email",
+    "needles": [
+     "ada.finch@example.test"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-10-get_search_book_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the search book with id 1 and query wick and report its `data[0].name`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states data[0].name",
+    "needles": [
+     "Wick and Lens Care"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-11-get_roles_by_id.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the roles with id 5 and report its `display_name`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states display_name",
+    "needles": [
+     "Tide Clerks"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/qa-12-get_shelves.json

@@ -0,0 +1,42 @@
+[
+ {
+  "id": "env",
+  "type": "deploy_env",
+  "env_id": "bookstack",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "agent",
+  "type": "deploy_agent",
+  "a2a_agent_id": "replay-qa",
+  "agent_name": "replay-qa",
+  "env_ids": [
+   "bookstack"
+  ],
+  "env_step_id": "env",
+  "sandbox_type": "local"
+ },
+ {
+  "id": "ask",
+  "type": "prompt_agent",
+  "agent_name": "replay-qa",
+  "prompt_id": "q",
+  "prompt": "In this BookStack environment, look up the shelves and report its `data[0].name`. Use only the environment's tools. Answer with the value only, nothing else.",
+  "max_turns": 6
+ },
+ {
+  "id": "grade",
+  "type": "agent_prompt_response_verifier",
+  "prompt_id": "q",
+  "verifier_id": "retrieval",
+  "criteria": [
+   {
+    "type": "response_contains",
+    "criterion": "response states data[0].name",
+    "needles": [
+     "Lighthouse Rota Handbooks"
+    ]
+   }
+  ]
+ }
+]

bundles/bookstack/tasks/smoke.json

@@ -0,0 +1,15 @@
+[
+  {
+    "id": "env",
+    "type": "deploy_env",
+    "env_id": "bookstack",
+    "sandbox_type": "local"
+  },
+  {
+    "id": "replay",
+    "type": "env_outcome_verifier",
+    "env_id": "bookstack",
+    "file_artifact_id": "check_bookstack",
+    "verifier_id": "replay"
+  }
+]

episodes/bookstack.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82b58ee6b8946d0d652a8a409a5fb1df5e8a90eb3e4872c296edd7dc948950d9
+size 22073

tasks/bookstack.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:448c609154843abfead32440fc69cde1d5a0b597c88b6bf83ae24c6cf286121e
+size 8310