REA computer-use environment, v0.1.0

README.md

@@ -0,0 +1,92 @@
+---
+license: apache-2.0
+pretty_name: Geany computer-use environment (REA)
+tags:
+- computer-use
+- cua
+- gui-agent
+- rl-environment
+- agentenv
+- desktop
+- linux
+- rea
+- code-editor
+---
+
+# Geany: a computer-use environment
+
+![An agent solving the task in Geany](media/hero.gif)
+
+**The real Geany 2.0 code editor running on an Ubuntu 24.04 desktop, as an [agentenv](https://pypi.org/project/agentenv-framework/) computer environment. An agent completes the task only through screenshots, mouse and keyboard, and a verifier grades the saved files with no model.**
+
+Geany opens a small Python settings file for a corner shop. The agent has to find two settings in the editor, turn debug mode off and move the port from 8000 to 8080, then save. It sees only the screen and acts only with the mouse and keyboard.
+
+## Watch
+
+- Agent runs (Claude Code with Claude Sonnet 5.5): [run 1](media/solve-1.mp4), [run 2](media/solve-2.mp4), [run 3](media/solve-3.mp4)
+- Scripted witness, which proves the task can be done through the computer: [witness.mp4](media/witness.mp4)
+
+Each video is the computer's own screen recording at 10 frames per second.
+
+## The task
+
+> In the shop's settings.py open in Geany, turn debug mode off and change the port to 8080, then save the file.
+
+`bundle/artifacts/debug-off-check/verify.py` reads the app's files through the computer's `data/get` view and passes only if every check holds:
+
+| Check | Kind | File |
+| --- | --- | --- |
+| `changed` | `lines_present` | `Documents/shop/settings.py` |
+| `old-gone` | `lines_absent` | `Documents/shop/settings.py` |
+| `rest-kept` | `lines_present` | `Documents/shop/settings.py` |
+
+The checks read the saved file line by line: the two new lines are present, the two old ones are gone, and the rest of the file is untouched.
+
+## Results
+
+3 of 3 runs passed, about $0.63 per run.
+
+| Run | Outcome | Turns | Cost | Video |
+| --- | --- | --- | --- | --- |
+| 1 | passed | 9 | $0.88 | [video](media/solve-1.mp4) |
+| 2 | passed | 9 | $0.63 | [video](media/solve-2.mp4) |
+| 3 | passed | 9 | $0.38 | [video](media/solve-3.mp4) |
+
+## Run it
+
+You need Docker. `agentenv-framework` builds the computer: Ubuntu 24.04 with the app installed from Ubuntu's archive (`geany` 2.0-1build2).
+
+```bash
+pip install agentenv-framework==0.9.1431
+hf download earakely-scale/GeanyComputerEnv-REA --repo-type dataset --local-dir geany
+agent-env run geany/bundle --task debug-off --agent claude-code --model <model>
+```
+
+The agent needs a model provider configured for agentenv. `--task smoke` only boots the computer, with no agent. `bundle/README.md` describes the bundle in detail.
+
+## How it was made
+
+[REA](https://github.com/morluto/rea) built this environment from a real session with the app:
+
+1. **Capture.** REA launched Geany on a Linux desktop and recorded its package, windows and opened files while a scripted user made the edit. It also recorded the app's state folders before and after.
+2. **Export.** REA turned the capture into an agentenv `computer_app`. It installs the app, seeds the starting files, starts the app, and waits for its main window. It also serves typed views of the app's files for verifiers.
+3. **Task.** The task's checks were validated against the capture: they fail on the starting state and pass on the captured end state.
+4. **Witness and runs.** Scripted computer actions solved the task in a fresh computer, and the verifier failed before, passed after and failed again after `data/reset`. Then an agent solved it 3 times, each run recorded.
+
+## What's inside
+
+```
+bundle/      the agentenv bundle: envs/ (app module, seed files), tasks/, artifacts/ (verifier), evals/
+media/       witness and agent-run recordings (MP4) with short GIF previews
+results.json the runs above, with each check's result
+```
+
+## Limits
+
+- The checks read whole lines, so an equivalent edit written differently (for example `DEBUG=False` without spaces) fails.
+- The computer uses the `geany` version in Ubuntu 24.04's archive at build time; it is not pinned.
+- Three runs is a small sample: the solve rate shows the task is solvable, not how hard it is.
+
+## Licences
+
+The bundle code, the task and the synthetic seed files are Apache-2.0. Geany itself is not included: the computer installs it from Ubuntu's archive (`geany` 2.0-1build2) at build time, under its own licence (GPL-2.0-or-later).

bundle/README.md

@@ -0,0 +1,40 @@
+# Geany computer app
+
+Exported by REA's `export-desktop-application` from a capture of the `geany` package
+(capture Evidence `ev_4684c2005297be81cf1370fb88326bd891831f5d8ffde813cc0b2e4bca4659a9`). It was checked against agentenv-framework
+0.9.1431.
+
+- `envs/geany/` is a computer app on the `ubuntu-24.04` base with the `reference` driver, for
+  `amd64` and `arm64`. It installs `geany` from the distribution archive, launches `sh -c exec 'geany' "$HOME"/'Documents/shop/settings.py'` at boot and is ready
+  when a window of class `Geany` appears.
+- Owned paths: `~/.config/geany`, `~/Documents/shop`.
+  `data/get` returns their files and a typed JSON view of each; `data/reset` restores the seed.
+- Seed: 6 file(s) from the user's home before the capture, with the captured home path
+  respelled in text files.
+- `tasks/smoke.json` deploys the app.
+
+Run the task with `agent-env run <this folder>`, or only the deploy with `--task smoke`.
+
+The seed is synthetic test data made for this showcase; it holds no one's real files.
+
+## Task `debug-off`
+
+`tasks/debug-off.json` deploys the app, has the agent work through the computer from the prompt below, and grades
+the outcome with `artifacts/debug-off-check/verify.py`, which reads the app's `data/get` views and needs
+no model. `evals/geany.toml` names it, so a run of the bundle runs it.
+
+> In the shop's settings.py open in Geany, turn debug mode off and change the port to 8080, then save the file.
+
+Checks, each of which must pass:
+
+- `changed`: `{"kind":"lines_present","file":"Documents/shop/settings.py","lines":["DEBUG = False","PORT = 8080"]}`
+- `old-gone`: `{"kind":"lines_absent","file":"Documents/shop/settings.py","lines":["DEBUG = True","PORT = 8000"]}`
+- `rest-kept`: `{"kind":"lines_present","file":"Documents/shop/settings.py","lines":["APP_NAME = \"Corner Shop\"","HOST = \"127.0.0.1\"","DATABASE_URL = \"sqlite:///shop.db\"","ITEMS_PER_PAGE = 20","CURRENCY = \"EUR\""]}`
+
+REA kept the task because its checks fail on the seed (`changed`, `old-gone`) and all
+pass on the captured end state.
+
+To measure a solve rate, run the task k times (3 by default) with the agent and model to measure, and count the runs
+whose summary line says `passed`; a run that says `failed` did not finish and is run again rather than counted:
+
+    agent-env run <this folder> --task debug-off --agent claude-code --model MODEL

bundle/artifacts/debug-off-check/verify.py

@@ -0,0 +1,200 @@
+"""Checks of the task debug-off against the geany app's state, exported by REA from a desktop application capture.
+
+It reads the app's data/get through the computer, takes the typed views of its files and evaluates each check: no
+model, no code from the task. A failure to reach the app raises, so the run fails rather than scoring the agent.
+"""
+import json
+import re
+
+from agentenv_protocol import client as protocol
+from agentenv_protocol.types import RPC_PATH
+
+APP = "geany"
+CHECKS = [
+    {"id": "changed", "kind": "lines_present", "file": "Documents/shop/settings.py", "lines": ["DEBUG = False", "PORT = 8080"]},
+    {"id": "old-gone", "kind": "lines_absent", "file": "Documents/shop/settings.py", "lines": ["DEBUG = True", "PORT = 8000"]},
+    {"id": "rest-kept", "kind": "lines_present", "file": "Documents/shop/settings.py", "lines": ["APP_NAME = \"Corner Shop\"", "HOST = \"127.0.0.1\"", "DATABASE_URL = \"sqlite:///shop.db\"", "ITEMS_PER_PAGE = 20", "CURRENCY = \"EUR\""]},
+]
+
+MISSING = object()
+
+
+def _shown(value) -> str:
+    text = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+    return text if len(text) <= 200 else text[:200] + "…"
+
+
+def _same(actual, expected) -> bool:
+    """JSON equality: numbers by value but never a boolean for a number, objects by their keys, arrays in order."""
+    if isinstance(expected, list):
+        return (isinstance(actual, list) and len(actual) == len(expected)
+                and all(_same(item, wanted) for item, wanted in zip(actual, expected)))
+    if isinstance(expected, dict):
+        return (isinstance(actual, dict) and len(actual) == len(expected)
+                and all(key in actual and _same(actual[key], value) for key, value in expected.items()))
+    if isinstance(expected, bool) or isinstance(actual, bool):
+        return isinstance(expected, bool) and isinstance(actual, bool) and actual == expected
+    if isinstance(expected, (int, float)):
+        return isinstance(actual, (int, float)) and actual == expected
+    return type(actual) is type(expected) and actual == expected
+
+
+def _resolve(view, pointer: str):
+    current = view
+    for raw in pointer[1:].split("/"):
+        token = raw.replace("~1", "/").replace("~0", "~")
+        if isinstance(current, list):
+            if not re.fullmatch(r"0|[1-9][0-9]*", token) or int(token) >= len(current):
+                return MISSING
+            current = current[int(token)]
+        elif isinstance(current, dict) and token in current:
+            current = current[token]
+        else:
+            return MISSING
+    return current
+
+
+def _truncated(form, view) -> bool:
+    if not isinstance(view, dict):
+        return False
+    if form in ("text", "xml"):
+        return view.get("truncated") is True
+    if form != "sqlite":
+        return False
+    tables = view.get("tables")
+    return view.get("tables_truncated") is True or any(
+        isinstance(table, dict) and (table.get("truncated") is True or isinstance(table.get("error"), str))
+        for table in (tables.values() if isinstance(tables, dict) else []))
+
+
+def _view_of(check, entry, form):
+    """The view, whether it is truncated, and why the check cannot read it; an absent file reads as empty."""
+    if entry is None:
+        return None, False, None
+    if isinstance(entry.get("error"), str):
+        return None, False, f"{check['file']} has no view: {entry['error']}"
+    if entry.get("format") in (None, "binary"):
+        return None, False, f"{check['file']} is binary and has no view"
+    if form is not None and entry.get("format") != form:
+        return None, False, f"{check['file']} is read as {entry.get('format')}, not {form}"
+    return entry.get("view"), _truncated(entry.get("format"), entry.get("view")), None
+
+
+def _undecided(check):
+    return False, f"the view of {check['file']} is truncated, so what it leaves out is unknown"
+
+
+def _compared(check, n: int, what: str):
+    operator = next(key for key in ("equals", "at_least", "at_most") if check.get(key) is not None)
+    expected = check[operator]
+    met = n == expected if operator == "equals" else n >= expected if operator == "at_least" else n <= expected
+    return met, f"{n} {what}, expected {operator.replace('_', ' ')} {expected}"
+
+
+def _lines(check, entry):
+    view, truncated, problem = _view_of(check, entry, "text")
+    if problem is not None:
+        return False, problem
+    lines = view.get("lines") if isinstance(view, dict) and isinstance(view.get("lines"), list) else []
+    lines = [line for line in lines if isinstance(line, str)]
+    file = check["file"]
+    if check["kind"] == "lines_present":
+        missing = next((line for line in check["lines"] if line not in lines), None)
+        return (True, f"{file} has the line(s) {_shown(check['lines'])}") if missing is None else (
+            False, f"{file} has no line {_shown(missing)}")
+    if truncated:
+        return _undecided(check)
+    if check["kind"] == "lines_absent":
+        found = next((line for line in check["lines"] if line in lines), None)
+        return (True, f"{file} has none of the lines {_shown(check['lines'])}") if found is None else (
+            False, f"{file} still has the line {_shown(found)}")
+    if check.get("contains") is not None:
+        n = sum(1 for line in lines if check["contains"] in line)
+        return _compared(check, n, f"line(s) of {file} contain {_shown(check['contains'])}")
+    n = sum(1 for line in lines if line == check["exact"])
+    return _compared(check, n, f"line(s) of {file} match {_shown(check['exact'])}")
+
+
+def _value(check, entry):
+    view, truncated, problem = _view_of(check, entry, None)
+    if problem is not None:
+        return False, problem
+    found = MISSING if entry is None else _resolve(view, check["pointer"])
+    at = f"{check['file']} at {check['pointer']}"
+    if check["kind"] == "value_equals" and isinstance(check["value"], (dict, list)) and truncated:
+        return _undecided(check)
+    if check["kind"] == "value_equals":
+        if found is not MISSING and _same(found, check["value"]):
+            return True, f"{at} is {_shown(check['value'])}"
+        return False, f"{at} has no value" if found is MISSING else f"{at} is {_shown(found)}, not {_shown(check['value'])}"
+    if truncated:
+        return _undecided(check)
+    return (True, f"{at} has no value") if found is MISSING else (False, f"{at} is {_shown(found)}")
+
+
+def _rows(check, entry):
+    view, _, problem = _view_of(check, entry, "sqlite")
+    if problem is not None:
+        return False, problem
+    view = view if isinstance(view, dict) else {}
+    tables = view.get("tables") if isinstance(view.get("tables"), dict) else {}
+    table = tables[check["table"]] if check["table"] in tables else MISSING
+    name = f"{check['file']} table {check['table']}"
+    if table is MISSING and view.get("tables_truncated") is True:
+        return _undecided(check)
+    table = table if isinstance(table, dict) else {}
+    if isinstance(table.get("error"), str):
+        return False, f"{name} could not be read: {table['error']}"
+    columns = table.get("columns") if isinstance(table.get("columns"), list) else []
+    rows = table.get("rows") if isinstance(table.get("rows"), list) else []
+    where = check.get("where") or {}
+
+    def matches(row) -> bool:
+        return isinstance(row, list) and all(
+            column in columns and columns.index(column) < len(row) and _same(row[columns.index(column)], value)
+            for column, value in where.items())
+
+    n = sum(1 for row in rows if matches(row))
+    if check["kind"] == "row_present":
+        return (n > 0, f"{name} has a row with {_shown(where)}" if n > 0 else f"{name} has no row with {_shown(where)}")
+    if table.get("truncated") is True:
+        return _undecided(check)
+    if check["kind"] == "row_absent":
+        return (True, f"{name} has no row with {_shown(where)}") if n == 0 else (
+            False, f"{name} has {n} row(s) with {_shown(where)}")
+    return _compared(check, n, f"row(s) of {name}" + (f" with {_shown(where)}" if "where" in check else ""))
+
+
+def _verdict(check, entry):
+    kind = check["kind"]
+    if kind == "file_present":
+        return (entry is not None, f"{check['file']} exists" if entry is not None else f"{check['file']} does not exist")
+    if kind == "file_absent":
+        return (entry is None, f"{check['file']} does not exist" if entry is None else f"{check['file']} exists")
+    if kind in ("lines_present", "lines_absent", "line_count"):
+        return _lines(check, entry)
+    if kind in ("value_equals", "value_absent"):
+        return _value(check, entry)
+    return _rows(check, entry)
+
+
+def evaluate(checks: list, views: dict) -> list:
+    """One result per check against the views data/get returned, by home path."""
+    results = []
+    for check in checks:
+        passed, description = _verdict(check, views.get(check["file"]))
+        results.append({"id": check["id"], "result": passed, "description": description})
+    return results
+
+
+async def verify(mcp_url, env_url):
+    card = await protocol.get_card(env_url)
+    child = protocol.find_child(card, APP)
+    if child is None:
+        raise RuntimeError(f"the computer at {env_url} lists no app named {APP}")
+    answer = await protocol.get_data(env_url + (child.get("url") or RPC_PATH).removesuffix(RPC_PATH), timeout=120)
+    states = [part.data["state"] for part in answer.parts
+              if part.kind == "data" and isinstance(part.data.get("state"), dict)]
+    if not states:
+        raise RuntimeError(f"the {APP} app's data/get returned no state views")
+    return evaluate(CHECKS, states[0])

bundle/envs/geany/SKILL.md

@@ -0,0 +1,10 @@
+---
+description: Use Geany on this Linux desktop; its window has class Geany.
+---
+
+# Geany
+
+Geany is open on the desktop at boot. Its window's class is `Geany`.
+
+Its files live under `~/.config/geany`, `~/Documents/shop`. Work through the application's own
+window and dialogs; the result is read from those files.

bundle/envs/geany/env.toml

@@ -0,0 +1,4 @@
+type = "computer_app"
+module = "geany_app.py:Geany"
+computer = "ubuntu-24.04"
+driver = "reference"

bundle/envs/geany/geany_app.py

@@ -0,0 +1,426 @@
+"""Geany as an agentenv computer app, exported by REA from a desktop application capture.
+
+Package: geany (captured at 2.0-1build2). Capture Evidence: ev_4684c2005297be81cf1370fb88326bd891831f5d8ffde813cc0b2e4bca4659a9.
+The seed is synthetic test data made for this showcase.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import math
+import os
+import re
+import sqlite3
+import subprocess
+import sys
+import tempfile
+import xml.etree.ElementTree as ElementTree
+from pathlib import Path
+
+from agentenv_protocol import add_data, get_data, reset_data
+from agentenv_protocol.computer import AptSource, ComputerAppEnvironment, Download, Launch, Packages, Ready, RunScript, computer_app, linux, ready_check
+from agentenv_protocol.computer.app_data import INITIAL, add, get, in_thread, keep_initial, reset
+from agentenv_protocol.types import DataPart
+
+HERE = Path(__file__).resolve().parent
+CAPTURED_HOME = "/home/ada"
+PATHS = [".config/geany", "Documents/shop"]
+DCONF = ""
+TEXT_SEEDS = frozenset([".config/geany/filedefs/filetypes.README", ".config/geany/geany.conf", ".config/geany/keybindings.conf", ".config/geany/session.conf", ".config/geany/templates/templates.README", "Documents/shop/settings.py"])
+WINDOW_CLASS = "Geany"
+
+XML_SUFFIXES = (".xml", ".xbel", ".plist", ".svg", ".ui")
+GROUP_HEADER = re.compile(r"^\[([^\]]+)\]$")
+LINE_BREAK = re.compile(r"\r?\n")
+SQLITE_HEADER = b"SQLite format 3\x00"
+XML_SPACE = "{http://www.w3.org/XML/1998/namespace}space"
+MAX_VIEW_BYTES = 64 * 1024 * 1024
+MAX_SAFE_INTEGER = 2**53 - 1
+MAX_TABLES = 64
+MAX_ROWS = 500
+MAX_LINES = 5000
+MAX_XML_NODES = 5000
+MAX_XML_DEPTH = 64
+SQLITE_BUSY_S = 0.25
+
+
+def _respelled(text: str, home: Path) -> str:
+    """The captured home path respelled to this computer's home, only where a whole path segment ends after it."""
+    return re.sub(re.escape(CAPTURED_HOME) + r"(?![\w.@+~-])", lambda _: str(home), text)
+
+
+def _respelled_utf16(data: bytes, home: Path) -> bytes:
+    """A UTF-16 text file with a byte-order mark respelled like a text seed, its mark kept; any other bytes as given."""
+    for mark, codec in ((b"\xff\xfe", "utf-16-le"), (b"\xfe\xff", "utf-16-be")):
+        if data.startswith(mark):
+            try:
+                text = data[len(mark):].decode(codec)
+            except UnicodeDecodeError:
+                return data
+            return mark + _respelled(text, home).encode(codec) if CAPTURED_HOME in text else data
+    return data
+
+
+#: What marks a window as not yet the app's own: skipping the taskbar, as splash screens and dialogs do, or a splash type.
+SPLASH_MARKS = ("_NET_WM_STATE_SKIP_TASKBAR", "_NET_WM_WINDOW_TYPE_SPLASH")
+
+
+def _taskbar_window(window_class: str) -> bool:
+    """Whether a top-level window of the given class that the taskbar lists is shown; a splash screen or a dialog
+    skips the taskbar."""
+    def xprop(*args: str) -> str:
+        done = subprocess.run(["xprop", *args], capture_output=True, text=True)
+        return done.stdout if done.returncode == 0 else ""
+
+    for window in re.findall(r"0x[0-9a-f]+", xprop("-root", "_NET_CLIENT_LIST").partition("#")[2]):
+        props = xprop("-id", window, "WM_CLASS", "_NET_WM_STATE", "_NET_WM_WINDOW_TYPE")
+        classes = re.findall(r'"((?:[^"\\]|\\.)*)"', props.partition("WM_CLASS")[2].split("\n", 1)[0])
+        if window_class in classes and not any(mark in props for mark in SPLASH_MARKS):
+            return True
+    return False
+
+
+def _seed_home(home: Path) -> None:
+    """Copy the captured files into this computer's home; text files, UTF-16 ones too, have the captured home path
+    respelled."""
+    seed = HERE / "seed"
+    for source in sorted(seed.rglob("*")) if seed.is_dir() else []:
+        if not source.is_file():
+            continue
+        relative = source.relative_to(seed).as_posix()
+        target = home / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        data = source.read_bytes()
+        if relative in TEXT_SEEDS:
+            data = _respelled(data.decode("utf-8"), home).encode("utf-8")
+        else:
+            data = _respelled_utf16(data, home)
+        target.write_bytes(data)
+
+
+def _dconf(arguments: list, environment: dict) -> str:
+    return subprocess.run(["dconf", *arguments], env={**os.environ, **environment}, capture_output=True, text=True,
+                          check=True).stdout
+
+
+def _load_dconf(home: Path) -> None:
+    """Compile the captured dconf keys into the user database without D-Bus, which is not up yet. Keys already there
+    stay unless captured: dconf compile reads the key files in name order and a later file wins. A failure is
+    reported and the app starts without them."""
+    if not DCONF:
+        return
+    database = home / ".config" / "dconf" / "user"
+    try:
+        database.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.TemporaryDirectory(dir=database.parent) as scratch:
+            keyfiles = Path(scratch, "keyfiles")
+            keyfiles.mkdir()
+            if database.is_file():
+                profile = Path(scratch, "profile")
+                profile.write_text(f"file-db:{database}\n")
+                existing = _dconf(["dump", "/"], {"DCONF_PROFILE": str(profile)})
+                (keyfiles / "00-existing").write_text(existing)
+            (keyfiles / "01-captured").write_text(_respelled(DCONF, home))
+            _dconf(["compile", str(Path(scratch, "user")), str(keyfiles)], {})
+            os.replace(Path(scratch, "user"), database)
+    except (OSError, subprocess.CalledProcessError) as error:
+        detail = (getattr(error, "stderr", None) or "").strip().splitlines()
+        print(f"warning: the captured dconf settings were not loaded: {detail[-1] if detail else error}",
+              file=sys.stderr)
+
+
+def _sqlite_text(data: bytes):
+    text = data.decode("utf-8", "replace")
+    return {"text": text, "bytes_hex": data.hex()} if "�" in text else text
+
+
+def _cell(value):
+    if isinstance(value, bytes):
+        return {"blob_hex": value.hex()}
+    if isinstance(value, int) and abs(value) > MAX_SAFE_INTEGER:
+        return {"integer": str(value)}
+    # JSON has no infinities or negative zero; REA's SQLite reader spells them as strings.
+    if isinstance(value, float) and (math.isinf(value) or (value == 0 and math.copysign(1, value) < 0)):
+        return "Infinity" if value == math.inf else "-Infinity" if value == -math.inf else "-0"
+    return value
+
+
+def _table(db, name: str, primary_key: list) -> dict:
+    quoted = '"' + name.replace('"', '""') + '"'
+    cursor = db.execute(f"select * from main.{quoted} not indexed limit {MAX_ROWS + 1}")
+    rows = [[_cell(value) for value in row] for row in cursor]
+    return {"columns": [column[0] for column in cursor.description], "primary_key": primary_key,
+            "rows": rows[:MAX_ROWS], "truncated": len(rows) > MAX_ROWS}
+
+
+def _sqlite(path: Path) -> dict:
+    """The database's ordinary tables, in schema order, up to REA's table and row limits."""
+    with contextlib.closing(sqlite3.connect(path.resolve().as_uri() + "?mode=ro", uri=True, timeout=SQLITE_BUSY_S)) as db:
+        kinds = dict(db.execute("select name, type from pragma_table_list where schema = 'main'"))
+        names = [name for (name,) in db.execute("select name from sqlite_schema where type = 'table'")
+                 if kinds.get(name) == "table"]
+        keys = {name: [key for (key,) in db.execute(
+            "select name from pragma_table_info(?, 'main') where pk > 0 order by pk", (name,))]
+            for name in names[:MAX_TABLES]}
+        db.text_factory = _sqlite_text
+        tables = {name: _table(db, name, keys[name]) for name in names[:MAX_TABLES]}
+    cut = len(names) > MAX_TABLES
+    return {"format": "sqlite", "view": {"tables": tables, "tables_truncated": cut},
+            "truncated": cut or any(table["truncated"] for table in tables.values())}
+
+
+def _text(text: str) -> dict:
+    lines = LINE_BREAK.split(text)
+    if lines[-1] == "":
+        lines.pop()
+    view = {"lines": lines[:MAX_LINES], "line_count": len(lines), "truncated": len(lines) > MAX_LINES}
+    return {"format": "text", "view": view, "truncated": view["truncated"]}
+
+
+def _keyfile_line(raw: str) -> tuple:
+    """A key file line as REA reads it: skip (blank or comment), group, entry or other."""
+    line = raw.strip()
+    if not line or line[0] in "#;":
+        return ("skip",)
+    header = GROUP_HEADER.match(line)
+    if header:
+        return ("group", header.group(1))
+    key, equals, value = line.partition("=")
+    return ("entry", key.strip(), value.strip()) if equals and key else ("other",)
+
+
+def _is_keyfile(text: str) -> bool:
+    """REA's rule: at least one group, and nothing a key file view would drop."""
+    kinds = {_keyfile_line(line)[0] for line in LINE_BREAK.split(text)}
+    return "group" in kinds and "other" not in kinds
+
+
+def _keyfile(text: str) -> dict:
+    groups, group = {}, ""
+    for line in map(_keyfile_line, LINE_BREAK.split(text)):
+        if line[0] == "group":
+            group = line[1]
+            groups.setdefault(group, {})
+        elif line[0] == "entry":
+            groups.setdefault(group, {})[line[1]] = line[2]
+    return groups
+
+
+class _XmlTree(ElementTree.TreeBuilder):
+    """Keeps comments and processing instructions, which REA's node limit counts, and refuses DOCTYPEs as REA does."""
+
+    def __init__(self) -> None:
+        super().__init__(insert_comments=True, insert_pis=True)
+
+    def doctype(self, name, pubid, system) -> None:
+        raise ValueError("the document declares a DOCTYPE")
+
+
+def _xml_children(element) -> list:
+    nodes = [element.text] if element.text else []
+    for child in element:
+        nodes.append(child)
+        if child.tail:
+            nodes.append(child.tail)
+    return nodes
+
+
+def _xml(node, depth: int, budget: dict, scope: tuple):
+    """A node as REA's XML view keeps it: an element with its attributes and children, or its text; None when it is
+    formatting whitespace, a comment, or past REA's node and depth limits."""
+    if budget["remaining"] <= 0 or depth > MAX_XML_DEPTH:
+        budget["truncated"] = True
+        return None
+    budget["remaining"] -= 1
+    preserve, element_content = scope
+    if isinstance(node, str):
+        return None if not node.strip() and element_content and not preserve else node
+    if not isinstance(node.tag, str):
+        return None
+    space = node.get(XML_SPACE)
+    nodes = _xml_children(node)
+    inner = (space == "preserve" if space else preserve,
+             any(not isinstance(child, str) and isinstance(child.tag, str) for child in nodes))
+    children = [_xml(child, depth + 1, budget, inner) for child in nodes]
+    return {"name": node.tag, "attributes": dict(node.attrib), "children": [c for c in children if c is not None]}
+
+
+def _xml_view(text: str):
+    parser = ElementTree.XMLParser(target=_XmlTree())
+    try:
+        parser.feed(text)
+        root = parser.close()
+    except (ElementTree.ParseError, ValueError):
+        return None
+    budget = {"remaining": MAX_XML_NODES, "truncated": False}
+    tree = _xml(root, 0, budget, (False, False))
+    return None if tree is None else {"root": tree, "truncated": budget["truncated"]}
+
+
+def _not_json(constant: str):
+    raise ValueError(f"{constant} is not JSON")
+
+
+class _Inexact(Exception):
+    """A JSON number that REA's state view refuses, since reading it would change it."""
+
+
+def _digits(text: str) -> str:
+    return re.split(r"[eE]", text.lstrip("-"))[0].replace(".", "").strip("0") or "0"
+
+
+def _js_string(value: float) -> str:
+    """How JavaScript's String() writes a finite double: an integer below 1e21 in full, any other in shortest form."""
+    return str(int(value)) if value.is_integer() and abs(value) < 1e21 else repr(value)
+
+
+def _safe_number(text: str) -> bool:
+    """lossless-json's isSafeNumber: an integer spelling within 2^53, or a float spelling that keeps its digits."""
+    if re.fullmatch(r"-?[0-9]+", text):
+        return len(text.lstrip("-")) <= 16 and abs(int(text)) <= MAX_SAFE_INTEGER
+    value = float(text)
+    if not math.isfinite(value):
+        return False
+    written = _js_string(value)
+    return written == text or _digits(written) == _digits(text)
+
+
+def _exact_number(text: str):
+    """A JSON number read only when reading it changes nothing, as REA's state view rules: its spelling and its
+    written-back form both safe, and not -0."""
+    value = float(text)
+    if (not _safe_number(text) or not math.isfinite(value) or not _safe_number(_js_string(value))
+            or (value == 0 and math.copysign(1, value) < 0)):
+        raise _Inexact(text)
+    return int(text) if re.fullmatch(r"-?[0-9]+", text) else value
+
+
+_INEXACT = object()
+_INEXACT_END = object()
+
+
+def _number_or_mark(spelling: str):
+    """A JSON number read exactly, or a mark for one REA's state view refuses."""
+    try:
+        return _exact_number(spelling)
+    except _Inexact:
+        return _INEXACT
+
+
+def _holds_inexact(value) -> bool:
+    """Whether a parsed JSON value still holds a marked number once duplicate keys kept their last value; one
+    iterator per nesting level, so no child list is copied."""
+    levels = [iter((value,))]
+    while levels:
+        item = next(levels[-1], _INEXACT_END)
+        if item is _INEXACT_END:
+            levels.pop()
+        elif item is _INEXACT:
+            return True
+        elif isinstance(item, dict):
+            levels.append(iter(item.values()))
+        elif isinstance(item, list):
+            levels.append(iter(item))
+    return False
+
+
+def _text_view(name: str, text: str) -> dict:
+    """The format REA's state view detects for decoded text, and its view."""
+    trimmed = re.sub(r"^[\s]+", "", text)
+    if name.endswith(".json") or trimmed[:1] in ("[", "{"):
+        # The whole text must parse, and duplicate keys settle, before an inexact number makes it JSON with an error.
+        try:
+            view = json.loads(text, parse_constant=_not_json, parse_float=_number_or_mark, parse_int=_number_or_mark)
+        except ValueError:
+            pass
+        else:
+            if _holds_inexact(view):
+                return {"format": "json", "view": None,
+                        "error": "a number in it cannot be read exactly, such as an integer above 2^53"}
+            return {"format": "json", "view": view, "truncated": False}
+    lowered = name.lower()
+    if lowered.endswith(XML_SUFFIXES) or trimmed.startswith("<?xml"):
+        view = _xml_view(text)
+        return _text(text) if view is None else {"format": "xml", "view": view, "truncated": view["truncated"]}
+    if _is_keyfile(text):
+        return {"format": "keyfile", "view": {"groups": _keyfile(text)}, "truncated": False}
+    return _text(text)
+
+
+def _view(path: Path) -> dict:
+    """A typed JSON view of one file in the shapes of REA's state view; truncated says the view is partial."""
+    too_large = {"format": None, "view": None, "error": "larger than 64 MiB, the most the view reads"}
+    if path.stat().st_size > MAX_VIEW_BYTES:
+        return too_large
+    with path.open("rb") as file:
+        data = file.read(8192)
+        whole = not data.startswith(SQLITE_HEADER) and b"\x00" not in data
+        data += file.read(MAX_VIEW_BYTES + 1 - len(data)) if whole else b""
+    if data.startswith(SQLITE_HEADER):
+        return _sqlite(path)
+    if len(data) > MAX_VIEW_BYTES:
+        return too_large
+    try:
+        text = data.decode("utf-8-sig") if whole else None
+    except UnicodeDecodeError:
+        text = None
+    return {"format": "binary", "view": None, "truncated": False} if text is None else _text_view(path.name, text)
+
+
+def _views(home: Path, paths: list) -> dict:
+    """A view of every file under the app's paths, keyed by its home-relative path."""
+    files = {}
+    for owned in paths:
+        root = home / owned
+        candidates = [root] if root.is_file() else sorted(root.rglob("*")) if root.is_dir() else []
+        for path in candidates:
+            if path.is_file() and not path.is_symlink():
+                key = path.relative_to(home).as_posix()
+                try:
+                    files[key] = _view(path)
+                except (OSError, ValueError, sqlite3.Error, RecursionError) as error:
+                    files[key] = {"format": None, "view": None, "error": str(error)}
+    return files
+
+
+@computer_app(supports=[{"os": {"type": "linux", "display": ["x11"]}, "arch": ["amd64", "arm64"]}])
+@linux(
+    packages=Packages(apt=["geany"]),
+    launch=Launch(at="boot", command=["sh", "-c", "exec 'geany' \"$HOME\"/'Documents/shop/settings.py'"], window={"class": "Geany"}, ready=Ready(window=True)),
+    paths=PATHS,
+    skill="SKILL.md",
+)
+class Geany(ComputerAppEnvironment):
+    """Geany, launched at boot with the captured state in its home.
+
+    Declaring data hooks switches off agentenv's default data plane, so these call its helpers: the seed is kept as
+    the initial state, reset restores it, add writes files under PATHS, and get returns those files plus a typed JSON
+    view of each.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        if not INITIAL.exists():
+            _seed_home(Path.home())
+            _load_dconf(Path.home())
+        keep_initial(self.paths)
+
+    @add_data
+    async def add_files(self, parts: list) -> None:
+        await add(parts, self.paths)
+
+    @get_data
+    async def get_files(self, write_namespace=None) -> list:
+        files = await get(self.paths, write_namespace)
+        views = await in_thread(_views, Path.home(), self.paths)
+        return [*files, DataPart(data={"state": views})]
+
+    @reset_data
+    async def reset_files(self) -> None:
+        await reset(self.paths)
+
+    @ready_check
+    def main_window_shown(self) -> bool:
+        """A window of the app's class that the taskbar lists is shown, not only a splash screen or a dialog."""
+        return _taskbar_window(WINDOW_CLASS)

bundle/envs/geany/seed/.config/geany/filedefs/filetypes.README

@@ -0,0 +1,2 @@
+Copy files from /usr/share/geany/filedefs to this directory to overwrite them. To use the defaults, just delete the file in this directory.
+For more information read the documentation (in /usr/share/doc/geany/html/index.html or visit https://www.geany.org/).

bundle/envs/geany/seed/.config/geany/geany.conf

@@ -0,0 +1,188 @@
+[geany]
+pref_main_load_session=true
+pref_main_project_file_in_basedir=true
+pref_main_save_winpos=true
+pref_main_save_wingeom=true
+pref_main_confirm_exit=false
+pref_main_suppress_status_messages=false
+switch_msgwin_pages=false
+beep_on_errors=true
+auto_focus=false
+sidebar_symbol_visible=true
+sidebar_openfiles_visible=true
+editor_font=Monospace 10
+tagbar_font=Sans 9
+msgwin_font=Monospace 9
+show_notebook_tabs=true
+show_tab_cross=true
+tab_order_ltr=true
+tab_order_beside=false
+tab_pos_editor=2
+tab_pos_msgwin=0
+tab_label_length=1000
+show_indent_guide=false
+show_white_space=false
+show_line_endings=false
+show_line_endings_only_when_differ=false
+show_markers_margin=true
+show_linenumber_margin=true
+long_line_enabled=true
+long_line_type=0
+long_line_column=72
+long_line_color=#C2EBC2
+symbolcompletion_max_height=10
+symbolcompletion_min_chars=4
+use_folding=true
+unfold_all_children=false
+use_indicators=true
+line_wrapping=false
+auto_close_xml_tags=true
+complete_snippets=true
+auto_complete_symbols=true
+pref_editor_disable_dnd=false
+pref_editor_smart_home_key=true
+pref_editor_newline_strip=false
+line_break_column=72
+auto_continue_multiline=true
+comment_toggle_mark=~ 
+scroll_stop_at_last_line=true
+autoclose_chars=0
+pref_editor_default_new_encoding=UTF-8
+pref_editor_default_open_encoding=none
+default_eol_character=2
+pref_editor_new_line=true
+pref_editor_ensure_convert_line_endings=false
+pref_editor_replace_tabs=false
+pref_editor_trail_space=false
+pref_toolbar_show=true
+pref_toolbar_append_to_menu=false
+pref_toolbar_use_gtk_default_style=true
+pref_toolbar_use_gtk_default_icon=true
+pref_toolbar_icon_style=0
+pref_toolbar_icon_size=0
+pref_template_developer=Unknown
+pref_template_company=
+pref_template_mail=ada@e81232be457d
+pref_template_initial=U
+pref_template_version=1.0
+pref_template_year=%Y
+pref_template_date=%Y-%m-%d
+pref_template_datetime=%d.%m.%Y %H:%M:%S %Z
+context_action_cmd=
+sidebar_visible=true
+statusbar_visible=true
+msgwindow_visible=true
+fullscreen=false
+symbols_group_by_type=true
+color_picker_palette=
+scribble_text=Type here what you want, use it as a notice/scratch board
+scribble_pos=57
+custom_date_format=
+default_open_path=
+cmdline_new_files=true
+notebook_double_click_hides_widgets=false
+tab_close_switch_to_mru=false
+tab_pos_sidebar=2
+openfiles_path_mode=2
+sidebar_pos=0
+symbols_sort_mode=0
+msgwin_orientation=1
+highlighting_invert_all=false
+pref_main_search_use_current_word=true
+check_detect_indent=false
+detect_indent_width=false
+use_tab_to_indent=true
+backspace_unindent=true
+pref_editor_tab_width=4
+indent_mode=2
+indent_type=1
+virtualspace=1
+change_history_markers=false
+change_history_indicators=false
+autocomplete_doc_words=false
+completion_drops_rest_of_word=false
+autocompletion_max_entries=30
+autocompletion_update_freq=250
+color_scheme=
+scroll_lines_around_cursor=0
+mru_length=10
+disk_check_timeout=30
+show_editor_scrollbars=true
+brace_match_ltgt=false
+use_gtk_word_boundaries=true
+complete_snippets_whilst_editing=false
+indent_hard_tab_width=8
+editor_ime_interaction=0
+use_atomic_file_saving=false
+gio_unsafe_save_backup=false
+use_gio_unsafe_file_saving=true
+keep_edit_history_on_reload=true
+show_keep_edit_history_on_reload_msg=true
+reload_clean_doc_on_file_change=false
+save_config_on_file_change=true
+extract_filetype_regex=-\\*-\\s*([^\\s]+)\\s*-\\*-
+allow_always_save=false
+find_selection_type=0
+replace_and_find_by_default=true
+show_symbol_list_expanders=true
+compiler_tab_autoscroll=true
+statusbar_template=line: %l / %L	 col: %c	 sel: %s	 %w      %t      %mEOL: %M      encoding: %e      filetype: %f      scope: %S
+new_document_after_close=false
+msgwin_status_visible=true
+msgwin_compiler_visible=true
+msgwin_messages_visible=true
+msgwin_scribble_visible=true
+warn_on_project_close=true
+
+[tools]
+terminal_cmd=x-terminal-emulator -e "/bin/sh %c"
+browser_cmd=
+grep_cmd=grep
+
+[printing]
+print_cmd=
+use_gtk_printing=true
+print_line_numbers=true
+print_page_numbers=true
+print_page_header=true
+page_header_basename=false
+page_header_datefmt=%c
+
+[VTE]
+load_vte=true
+send_cmd_prefix=
+send_selection_unsafe=false
+
+[build-menu]
+number_ft_menu_items=0
+number_non_ft_menu_items=0
+number_exec_menu_items=0
+
+[search]
+pref_search_hide_find_dialog=false
+pref_search_always_wrap=false
+pref_search_current_file_dir=true
+fif_regexp=false
+fif_case_sensitive=true
+fif_match_whole_word=false
+fif_invert_results=false
+fif_recursive=false
+fif_extra_options=
+fif_use_extra_options=false
+fif_files=
+fif_files_mode=0
+find_regexp=false
+find_regexp_multiline=false
+find_case_sensitive=false
+find_escape_sequences=false
+find_match_whole_word=false
+find_match_word_start=false
+find_close_dialog=true
+replace_regexp=false
+replace_regexp_multiline=false
+replace_case_sensitive=false
+replace_escape_sequences=false
+replace_match_whole_word=false
+replace_match_word_start=false
+replace_search_backwards=false
+replace_close_dialog=true

bundle/envs/geany/seed/.config/geany/session.conf

@@ -0,0 +1,29 @@
+[files]
+recent_files=
+recent_projects=
+current_page=0
+
+[project]
+session_file=
+project_file_path=/home/ada/projects
+
+[geany]
+treeview_position=156
+msgwindow_position=368
+geometry=0;0;900;600;0;
+sidebar_page=0
+
+[search]
+find_all_expanded=false
+replace_all_expanded=false
+position_find_x=-1
+position_find_y=-1
+position_replace_x=-1
+position_replace_y=-1
+position_fif_x=-1
+position_fif_y=-1
+
+[plugins]
+load_plugins=true
+custom_plugin_path=
+active_plugins=;

bundle/envs/geany/seed/.config/geany/templates/templates.README

@@ -0,0 +1,2 @@
+There are several template files in this directory. For these templates you can use wildcards.
+For more information read the documentation (in /usr/share/doc/geany/html/index.html or visit https://www.geany.org/).

bundle/envs/geany/seed/Documents/shop/settings.py

@@ -0,0 +1,9 @@
+"""Settings for the corner shop web app."""
+
+APP_NAME = "Corner Shop"
+DEBUG = True
+HOST = "127.0.0.1"
+PORT = 8000
+DATABASE_URL = "sqlite:///shop.db"
+ITEMS_PER_PAGE = 20
+CURRENCY = "EUR"

bundle/evals/geany.toml

@@ -0,0 +1 @@
+tasks = ["debug-off"]

bundle/tasks/debug-off.json

@@ -0,0 +1,9 @@
+[
+  {"id":"env","type":"deploy_env","env_id":"geany"},
+  {"id":"agent","type":"deploy_agent","env_ids":["geany"]},
+  {"id":"skills","type":"add_skills","env_ids":["geany"]},
+  {"id":"record","type":"start_computer_recording","env_id":"geany","name":"agent","depends_on":["env"]},
+  {"id":"task","type":"prompt_agent","depends_on":["skills","record"],"prompt":"In the shop's settings.py open in Geany, turn debug mode off and change the port to 8080, then save the file."},
+  {"id":"check","type":"env_outcome_verifier","env_id":"geany","file_artifact_id":"debug-off-check","verifier_id":"debug-off","depends_on":["task"]},
+  {"id":"end","type":"end_computer_recording","name":"agent","depends_on":["task"]}
+]

bundle/tasks/smoke.json

@@ -0,0 +1,7 @@
+[
+  {
+    "id": "env",
+    "type": "deploy_env",
+    "env_id": "geany"
+  }
+]

media/solve-1.mp4

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

media/solve-2.mp4

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

media/solve-3.mp4

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

media/witness.mp4

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

results.json

@@ -0,0 +1,96 @@
+{
+  "environment": "Geany",
+  "app_version": "Geany 2.0 code editor",
+  "task": "debug-off",
+  "prompt": "In the shop's settings.py open in Geany, turn debug mode off and change the port to 8080, then save the file.",
+  "agent": "claude-code",
+  "model": "claude-sonnet-5-5",
+  "agentenv_framework": "0.9.1431",
+  "witness": "verifier failed on the seed, passed after a scripted edit through computer actions, failed again after data/reset",
+  "runs": [
+    {
+      "run": 1,
+      "verdict": "passed",
+      "turns": 9,
+      "usd": 0.88,
+      "checks": {
+        "debug-off": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "changed",
+              "result": true,
+              "description": "Documents/shop/settings.py has the line(s) [\"DEBUG = False\",\"PORT = 8080\"]"
+            },
+            {
+              "id": "old-gone",
+              "result": true,
+              "description": "Documents/shop/settings.py has none of the lines [\"DEBUG = True\",\"PORT = 8000\"]"
+            },
+            {
+              "id": "rest-kept",
+              "result": true,
+              "description": "Documents/shop/settings.py has the line(s) [\"APP_NAME = \\\"Corner Shop\\\"\",\"HOST = \\\"127.0.0.1\\\"\",\"DATABASE_URL = \\\"sqlite:///shop.db\\\"\",\"ITEMS_PER_PAGE = 20\",\"CURRENCY = \\\"EUR\\\"\"]"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 2,
+      "verdict": "passed",
+      "turns": 9,
+      "usd": 0.63,
+      "checks": {
+        "debug-off": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "changed",
+              "result": true,
+              "description": "Documents/shop/settings.py has the line(s) [\"DEBUG = False\",\"PORT = 8080\"]"
+            },
+            {
+              "id": "old-gone",
+              "result": true,
+              "description": "Documents/shop/settings.py has none of the lines [\"DEBUG = True\",\"PORT = 8000\"]"
+            },
+            {
+              "id": "rest-kept",
+              "result": true,
+              "description": "Documents/shop/settings.py has the line(s) [\"APP_NAME = \\\"Corner Shop\\\"\",\"HOST = \\\"127.0.0.1\\\"\",\"DATABASE_URL = \\\"sqlite:///shop.db\\\"\",\"ITEMS_PER_PAGE = 20\",\"CURRENCY = \\\"EUR\\\"\"]"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 3,
+      "verdict": "passed",
+      "turns": 9,
+      "usd": 0.38,
+      "checks": {
+        "debug-off": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "changed",
+              "result": true,
+              "description": "Documents/shop/settings.py has the line(s) [\"DEBUG = False\",\"PORT = 8080\"]"
+            },
+            {
+              "id": "old-gone",
+              "result": true,
+              "description": "Documents/shop/settings.py has none of the lines [\"DEBUG = True\",\"PORT = 8000\"]"
+            },
+            {
+              "id": "rest-kept",
+              "result": true,
+              "description": "Documents/shop/settings.py has the line(s) [\"APP_NAME = \\\"Corner Shop\\\"\",\"HOST = \\\"127.0.0.1\\\"\",\"DATABASE_URL = \\\"sqlite:///shop.db\\\"\",\"ITEMS_PER_PAGE = 20\",\"CURRENCY = \\\"EUR\\\"\"]"
+            }
+          ]
+        }
+      }
+    }
+  ]
+}