REA computer-use environment, v0.1.0

README.md

@@ -0,0 +1,109 @@
+---
+license: apache-2.0
+pretty_name: Gnumeric computer-use environment from a one-line request (REA)
+tags:
+- computer-use
+- cua
+- gui-agent
+- rl-environment
+- agentenv
+- desktop
+- linux
+- rea
+- spreadsheet
+- office
+- from-request
+---
+
+# Gnumeric: a computer-use environment built from a one-line request
+
+![An agent solving the task in Gnumeric](media/hero.gif)
+
+**The real Gnumeric 1.12 spreadsheet 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.**
+
+Claude Code built this environment from a one-line request in about 20 minutes, with only REA's build skill and MCP tools; [How it was made](#how-it-was-made) has the request and the steps. Gnumeric opens a small household budget, `Documents/household-budget.xml`, at launch: rent, groceries, utilities and transport by month from January to April, with a Total row. The agent has to change March's Groceries figure from 405.10 to 437.80 and save, leaving every other figure alone. 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)
+- 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 my household budget spreadsheet, Documents/household-budget.xml, change the Groceries figure for March to 437.80 and save it.
+
+`bundle/artifacts/update-march-groceries-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 |
+| --- | --- | --- |
+| `march-groceries` | `value_equals` | `Documents/household-budget.xml` |
+| `february-groceries-untouched` | `value_equals` | `Documents/household-budget.xml` |
+| `april-groceries-untouched` | `value_equals` | `Documents/household-budget.xml` |
+| `march-utilities-untouched` | `value_equals` | `Documents/household-budget.xml` |
+
+The seed is saved as Gnumeric XML uncompressed (`.xml`) rather than Gnumeric's default gzip-compressed `.gnumeric`, so REA reads it as XML. Each check finds a cell by its `Row` and `Col` attributes, never by position, and compares its value within 0.001, because Gnumeric writes numbers with 17 significant digits (437.80000000000001). March Groceries must be 437.8, and February and April Groceries and March Utilities must keep their values, so an edit to a neighbouring cell fails. REA's draft suggested checks on where the cursor was left rather than on the edited cell; Claude Code wrote these instead.
+
+## Results
+
+3 of 3 runs passed, about $0.52 per run.
+
+| Run | Outcome | Turns | Cost | Video |
+| --- | --- | --- | --- | --- |
+| 1 | passed | 10 | $0.43 | [video](media/solve-1.mp4) |
+| 2 | passed | 10 | $0.69 | [video](media/solve-2.mp4) |
+| 3 | passed | 10 | $0.45 | [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 (`gnumeric` 1.12.56).
+
+```bash
+pip install agentenv-framework==0.9.1431
+hf download earakely-scale/GnumericFromRequestComputerEnv-REA --repo-type dataset --local-dir gnumeric-request
+agent-env run gnumeric-request/bundle --task update-march-groceries --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
+
+Claude Code built this environment from a one-line request, given only [REA](https://github.com/morluto/rea)'s build skill and REA's MCP tools:
+
+> Build me a Gnumeric environment where the agent updates one month's figure in a small household budget spreadsheet and saves it.
+
+It asked only the skill's upfront questions, wrote no app-specific scripts, and finished in about 20 minutes. The steps were REA's usual ones:
+
+1. **Capture.** REA launched Gnumeric on a Linux desktop and recorded its package, windows and opened files while the edit was made. 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.** In a fresh computer, the edit was made through computer actions alone, and the checks were read at four stages. They held on the first try:
+
+| Stage | Checks |
+| --- | --- |
+| `seed` | fail, as expected: March Groceries is 405.10 |
+| `after_edit` | pass |
+| `near_miss` | fail, as expected: March Groceries was typed as 473.80 |
+| `after_reset` | fail, as expected: `data/reset` restored the seed |
+
+The agent runs came after the build: Claude Code with Claude Sonnet 5.5 (`--model anthropic/claude-sonnet-5-5 --no-emulate`, on an amd64 host) solved the task 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 `Documents/household-budget.xml` as Gnumeric XML uncompressed. A correct edit saved under another name or format, such as Gnumeric's default `.gnumeric`, fails.
+- The Total row is not checked: Gnumeric stores its `=SUM` formulas, not their results.
+- The computer installs whatever `gnumeric` Ubuntu 24.04's archive holds at build time (1.12.56 for these runs); 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. Gnumeric itself is not included: the computer installs it from Ubuntu's archive (`gnumeric` 1.12.56) at build time, under its own licence (GPL-2.0-only or GPL-3.0-only).

bundle/README.md

@@ -0,0 +1,43 @@
+# Gnumeric computer app
+
+Exported by REA's `export-desktop-application` from a capture of the `gnumeric` package
+(capture Evidence `ev_48f15f32456e36e97c80d98ca9cacb40c5af4d575806f3a28e6fc3c5ac6047c4`). It was checked against agentenv-framework
+0.9.1431.
+
+- `envs/gnumeric/` is a computer app on the `ubuntu-24.04` base with the `reference` driver, for
+  `amd64` and `arm64`. It installs `gnumeric` from the distribution archive, launches `sh -c cd "$HOME" 2>/dev/null; exec 'gnumeric' '--name' 'org.gnumeric.gnumeric' "$HOME"/'Documents/household-budget.xml'` at boot and is ready
+  when a window of class `Gnumeric` appears.
+- At launch the app opens `~/Documents/household-budget.xml`, the seed's one document.
+- Owned paths: `~/Documents`.
+  `data/get` returns their files and a typed JSON view of each; `data/reset` restores the seed.
+- Seed: 1 file(s) made for the task, as saved at checkpoint `seed`.
+  Text files and dconf keys spell the capture host's name as `localhost`, `user@host` as `user@localhost`
+  and the home as `/home/user`, which the computer respells to its own at boot.
+- `tasks/smoke.json` deploys the app.
+
+Run the task with `agent-env run <this folder>`, or only the deploy with `--task smoke`.
+
+The seed was made for this task, not taken from a user's own data; read `envs/gnumeric/seed/` before publishing the bundle.
+
+## Task `update-march-groceries`
+
+`tasks/update-march-groceries.json` deploys the app, has the agent work through the computer from the prompt below, and grades
+the outcome with `artifacts/update-march-groceries-check/verify.py`, which reads the app's `data/get` views and needs
+no model. `evals/gnumeric.toml` names it, so a run of the bundle runs it.
+
+> In my household budget spreadsheet, Documents/household-budget.xml, change the Groceries figure for March to 437.80 and save it.
+
+Checks, each of which must pass:
+
+- `march-groceries`: `{"kind":"value_equals","file":"Documents/household-budget.xml","pointer":"/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=3]/children/0","value":437.8,"tolerance":0.001}`
+- `february-groceries-untouched`: `{"kind":"value_equals","file":"Documents/household-budget.xml","pointer":"/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=2]/children/0","value":398.2,"tolerance":0.001}`
+- `april-groceries-untouched`: `{"kind":"value_equals","file":"Documents/household-budget.xml","pointer":"/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=4]/children/0","value":421.75,"tolerance":0.001}`
+- `march-utilities-untouched`: `{"kind":"value_equals","file":"Documents/household-budget.xml","pointer":"/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=3][@Col=3]/children/0","value":174.9,"tolerance":0.001}`
+
+REA kept the task because its checks fail on the seed (`march-groceries`) 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 update-march-groceries --agent claude-code --model MODEL

bundle/artifacts/update-march-groceries-check/verify.py

@@ -0,0 +1,443 @@
+"""Checks of the task update-march-groceries against the gnumeric 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 math
+import re
+
+from agentenv_protocol import client as protocol
+from agentenv_protocol.types import RPC_PATH
+
+APP = "gnumeric"
+CHECKS = [
+    {"id": "march-groceries", "kind": "value_equals", "file": "Documents/household-budget.xml", "pointer": "/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=3]/children/0", "value": 437.8, "tolerance": 0.001},
+    {"id": "february-groceries-untouched", "kind": "value_equals", "file": "Documents/household-budget.xml", "pointer": "/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=2]/children/0", "value": 398.2, "tolerance": 0.001},
+    {"id": "april-groceries-untouched", "kind": "value_equals", "file": "Documents/household-budget.xml", "pointer": "/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=4]/children/0", "value": 421.75, "tolerance": 0.001},
+    {"id": "march-utilities-untouched", "kind": "value_equals", "file": "Documents/household-budget.xml", "pointer": "/root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=3][@Col=3]/children/0", "value": 174.9, "tolerance": 0.001},
+]
+
+MISSING = object()
+INDEX = re.compile(r"0|[1-9][0-9]*")
+VIEW_FORMATS = ("text", "json", "keyfile", "xml")
+NUMERAL = re.compile(r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?")
+WHITESPACE_RUN = re.compile(r"[ \t\r\n]+")
+
+
+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 _bracketed(token: str) -> bool:
+    return len(token) >= 2 and token.startswith("[") and token.endswith("]")
+
+
+def _selector(token: str):
+    """A selector's conditions, [KEY=VALUE] or [@KEY=VALUE] one or more times, or None when the token is not one."""
+    if not _bracketed(token):
+        return None
+    conditions = []
+    for part in token[1:-1].split("]["):
+        key, equals, value = part.partition("=")
+        name = key[1:] if key.startswith("@") else key
+        if not equals or not name:
+            return None
+        conditions.append((key.startswith("@"), name, value))
+    return conditions
+
+
+def _selects(member, conditions) -> bool:
+    """Whether an array member meets every condition; selectors compare strings only."""
+    if not isinstance(member, dict):
+        return False
+    for attribute, key, value in conditions:
+        fields = member.get("attributes") if attribute else member
+        if not isinstance(fields, dict) or not isinstance(fields.get(key), str) or fields[key] != value:
+            return False
+    return True
+
+
+def _step(items: list, token: str, last: bool):
+    """One step into an array, by index or by a selector that must match one member, or none when it is the last."""
+    if INDEX.fullmatch(token):
+        return ("member", items[int(token)]) if int(token) < len(items) else ("none", None)
+    conditions = _selector(token)
+    if conditions is None:
+        return ("unresolved", f"{token} is not a selector of the form [KEY=VALUE]") if _bracketed(token) else (
+            "none", None)
+    matched = [item for item in items if _selects(item, conditions)]
+    if len(matched) == 1:
+        return "member", matched[0]
+    if len(matched) > 1:
+        return "unresolved", f"{token} matches {len(matched)} members, not one"
+    return ("none" if last else "unresolved"), f"{token} matches no member"
+
+
+def _locate(view, pointer: str):
+    """Where a pointer leads: ("value", value), ("none", why or None) or ("unresolved", problem), with the pointers
+    to the arrays a selector searched on the way."""
+    current, searched = view, []
+    segments = pointer[1:].split("/")
+    for position, segment in enumerate(segments):
+        token = segment.replace("~1", "/").replace("~0", "~")
+        if isinstance(current, list):
+            if not INDEX.fullmatch(token) and _selector(token) is not None:
+                searched.append("".join("/" + part for part in segments[:position]))
+            kind, found = _step(current, token, position == len(segments) - 1)
+            if kind != "member":
+                return kind, found, searched
+            current = found
+        elif isinstance(current, dict) and token in current:
+            current = current[token]
+        else:
+            return "none", None, searched
+    return "value", current, searched
+
+
+def _number(value):
+    """A number, or a numeral string read as one; None for anything else, a boolean, or a numeral past the doubles."""
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return value
+    if not isinstance(value, str) or not NUMERAL.fullmatch(value):
+        return None
+    number = float(value)
+    return number if math.isfinite(number) else None
+
+
+def _entry_leaves_out(entry) -> bool:
+    return isinstance(entry, dict) and (isinstance(entry.get("view_error"), str) or (
+        entry.get("format") in ("text", "xml") and isinstance(entry.get("view"), dict)
+        and entry["view"].get("truncated") is True))
+
+
+def _viewless_entry(view, pointer: str):
+    """The name of the entry whose view a pointer goes into when it has none, so its null is no JSON value, and
+    why: binary, unread, or of a format without a view; None when it has one."""
+    parts = pointer[1:].split("/")
+    if len(parts) < 3 or parts[0] != "entries" or parts[2] != "view":
+        return None
+    kind, item, _ = _locate(view, "/entries/" + parts[1])
+    if kind != "value" or not isinstance(item, dict):
+        return None
+    if isinstance(item.get("view_error"), str):
+        reason = f"has no view: {item['view_error']}"
+    elif item.get("format") == "binary":
+        reason = "is binary and has no view"
+    elif item.get("format") not in VIEW_FORMATS:
+        reason = "has no view"
+    else:
+        return None
+    return (item["name"] if isinstance(item.get("name"), str) else ""), reason
+
+
+def _array_leaves_out(form, view, array: str) -> bool:
+    """Whether an array a selector searched may lack members: in a zip the listing or its entry's view, else the
+    view's own truncation."""
+    if form != "zip":
+        return _truncated(form, view)
+    if array == "/entries":
+        return isinstance(view, dict) and view.get("truncated") is True
+    return _zip_leaves_out(view, array)
+
+
+def _zip_leaves_out(view, pointer: str) -> bool:
+    """Whether a zip view leaves out what a pointer reaches: for a pointer into one listed entry, only that entry."""
+    if not isinstance(view, dict):
+        return False
+    parts = pointer[1:].split("/")
+    if parts[0] == "entries" and len(parts) > 1:
+        kind, entry, _ = _locate(view, "/entries/" + parts[1])
+        return _entry_leaves_out(entry) if kind == "value" else view.get("truncated") is True
+    entries = view.get("entries") if isinstance(view.get("entries"), list) else []
+    return view.get("truncated") is True or any(_entry_leaves_out(entry) for entry in entries)
+
+
+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 _near(at: str, found, expected, tolerance):
+    """A value compared within a tolerance: numbers, and numeral strings, by their difference."""
+    number = _number(found)
+    within = f"within {_shown(tolerance)} of {_shown(expected)}"
+    if number is None:
+        return False, f"{at} is {_shown(found)}, not a number"
+    if abs(number - expected) <= tolerance:
+        return True, f"{at} is {_shown(found)}, {within}"
+    return False, f"{at} is {_shown(found)}, not {within}"
+
+
+def _value(check, entry):
+    view, truncated, problem = _view_of(check, entry, None)
+    if problem is not None:
+        return False, problem
+    kind, found, searched = ("none", None, []) if entry is None else _locate(view, check["pointer"])
+    at = f"{check['file']} at {check['pointer']}"
+    viewless = _viewless_entry(view, check["pointer"]) if entry is not None and entry.get("format") == "zip" else None
+    if viewless is not None:
+        return False, f"{check['file']} entry {viewless[0]} {viewless[1]}"
+    # A selector tells one member from several only in an array the view holds whole.
+    if any(_array_leaves_out(entry.get("format"), view, array) for array in searched):
+        return _undecided(check)
+    if kind == "unresolved":
+        return False, f"{at}: {found}"
+    if entry is not None and entry.get("format") == "zip":
+        truncated = _zip_leaves_out(view, check["pointer"])
+    if check["kind"] == "value_equals" and isinstance(check["value"], (dict, list)) and truncated:
+        return _undecided(check)
+    if check["kind"] == "value_equals":
+        if kind == "none":
+            return False, f"{at} has no value" if found is None else f"{at}: {found}"
+        expected = check["value"]
+        if check.get("tolerance") is not None and isinstance(expected, (int, float)) and not isinstance(expected, bool):
+            return _near(at, found, expected, check["tolerance"])
+        if _same(found, check["value"]):
+            return True, f"{at} is {_shown(check['value'])}"
+        return False, f"{at} is {_shown(found)}, not {_shown(check['value'])}"
+    if truncated:
+        return _undecided(check)
+    return (True, f"{at} has no value") if kind == "none" else (False, f"{at} is {_shown(found)}")
+
+
+def _is_element(value) -> bool:
+    return (isinstance(value, dict) and isinstance(value.get("name"), str) and isinstance(value.get("attributes"), dict)
+            and isinstance(value.get("children"), list))
+
+
+def _element_text(element) -> str:
+    """An element's text as XPath's string() reads it from what the view keeps: every text node among its children
+    and its descendants', in document order."""
+    parts, pending = [], [element]
+    while pending:
+        node = pending.pop()
+        if isinstance(node, str):
+            parts.append(node)
+        elif _is_element(node):
+            pending.extend(reversed(node["children"]))
+    return "".join(parts)
+
+
+def _collapse_whitespace(text: str) -> str:
+    """Each run of XML whitespace (space, tab, CR, LF) made one space, none at either end, as normalize-space()."""
+    return WHITESPACE_RUN.sub(" ", text).strip(" ")
+
+
+def _text_at(view, pointer: str) -> bool:
+    """Whether a string a pointer reaches is text of the document: a member of an element's children (a text node)
+    or attributes (an attribute's value), rather than an element's name or a field of the DOCTYPE."""
+    segments = pointer.split("/")
+    if len(segments) < 3 or segments[-2] not in ("children", "attributes"):
+        return False
+    kind, owner, _ = _locate(view, "/".join(segments[:-2]))
+    return kind == "value" and _is_element(owner)
+
+
+def _not_xml_entry(check, view):
+    """Why a text check's pointer into an archive goes into no XML entry's view, or None when it does or names an
+    entry not listed."""
+    parts = check["pointer"].split("/")
+    if len(parts) < 4 or parts[3] != "view":
+        return f"{check['file']} at {check['pointer']} does not point into an entry's view"
+    if parts[1] != "entries":
+        return None
+    kind, item, _ = _locate(view, "/entries/" + parts[2])
+    if kind != "value" or not isinstance(item, dict) or item.get("format") == "xml":
+        return None
+    # An entry without a view failed before this, so its format is one with a view.
+    name, form = (value if isinstance(value, str) else "" for value in (item.get("name"), item.get("format")))
+    return f"{check['file']} entry {name} is read as {form}, not xml"
+
+
+def _whole_text(check, entry):
+    """An element's whole text, or a text node's, compared with the value or searched for it."""
+    view, truncated, problem = _view_of(check, entry, None)
+    if problem is not None:
+        return False, problem
+    at = f"{check['file']} at {check['pointer']}"
+    if entry is None:
+        return False, f"{at} has no value"
+    form = entry.get("format")
+    if form not in ("xml", "zip"):
+        return False, f"{check['file']} is read as {form}, not xml"
+    kind, found, searched = _locate(view, check["pointer"])
+    viewless = _viewless_entry(view, check["pointer"]) if form == "zip" else None
+    if viewless is not None:
+        return False, f"{check['file']} entry {viewless[0]} {viewless[1]}"
+    if any(_array_leaves_out(form, view, array) for array in searched):
+        return _undecided(check)
+    problem = _not_xml_entry(check, view) if form == "zip" else None
+    if problem is not None:
+        return False, problem
+    if kind == "unresolved":
+        return False, f"{at}: {found}"
+    if kind == "none":
+        return False, f"{at} has no value" if found is None else f"{at}: {found}"
+    if not (_text_at(view, check["pointer"]) if isinstance(found, str) else _is_element(found)):
+        return False, f"{at} is {_shown(found)}, not an element, a text node or an attribute value"
+    # A text node is whole; an element's text is whole only if its view left nothing out.
+    if form == "zip":
+        truncated = _zip_leaves_out(view, check["pointer"])
+    if not isinstance(found, str) and truncated:
+        return _undecided(check)
+    return _compared_text(check, at, _element_text(found))
+
+
+def _compared_text(check, at: str, found: str):
+    """A text found at a pointer compared with the check's value or searched for it, both collapsed when it asks."""
+    collapse = check.get("normalize_whitespace") is True
+    text = _collapse_whitespace(found) if collapse else found
+    value = _collapse_whitespace(check["value"]) if collapse else check["value"]
+    how = " with whitespace collapsed" if collapse else ""
+    if check["kind"] == "text_equals":
+        if text == value:
+            return True, f"{at} has the text {_shown(value)}{how}"
+        return False, f"{at} has the text {_shown(text)}{how}, not {_shown(value)}"
+    if value in text:
+        return True, f"{at} has text containing {_shown(value)}{how}"
+    return False, f"{at} has the text {_shown(text)}{how}, without {_shown(value)}"
+
+
+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)
+    if kind in ("text_equals", "text_contains"):
+        return _whole_text(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/gnumeric/SKILL.md

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

bundle/envs/gnumeric/env.toml

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

bundle/envs/gnumeric/gnumeric_app.py

@@ -0,0 +1,790 @@
+"""Gnumeric as an agentenv computer app, exported by REA from a desktop application capture.
+
+Package: gnumeric (captured at 1.12.56-2build5). Capture Evidence: ev_48f15f32456e36e97c80d98ca9cacb40c5af4d575806f3a28e6fc3c5ac6047c4.
+The seed was made for the task, as saved at checkpoint seed.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import copy
+import hashlib
+import io
+import json
+import math
+import os
+import re
+import sqlite3
+import struct
+import subprocess
+import sys
+import tempfile
+import zipfile
+import zlib
+from pathlib import Path
+from xml.parsers import expat
+
+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
+SEED_HOME = "/home/user"
+PATHS = ["Documents"]
+DCONF = ""
+TEXT_SEEDS = frozenset(["Documents/household-budget.xml"])
+WINDOW_CLASS = "Gnumeric"
+
+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"
+GVDB_HEADER = b"GVariant"
+ZIP_HEADER = b"PK\x03\x04"
+XML_SPACE = "xml: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
+MAX_PARSED_BYTES = 4 * 1024 * 1024
+MAX_JSON_VIEW_DEPTH = 500
+JSON_TOO_DEEP = f"nested deeper than the {MAX_JSON_VIEW_DEPTH} levels a JSON view keeps"
+
+
+def _respelled(text: str, home: Path) -> str:
+    """The seed's home path respelled to this computer's home, only where a whole path segment ends after it."""
+    return re.sub(re.escape(SEED_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 SEED_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 seed's 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
+
+
+#: XML's whitespace, which alone can be formatting between elements; Unicode's wider set is text.
+XML_WHITESPACE = " \t\r\n"
+PREDEFINED_ENTITIES = ("amp", "lt", "gt", "apos", "quot")
+ENTITY_REFERENCE = re.compile(r"&([^#;][^;]*);")
+
+
+def _expat(namespaces: bool, doctype=None):
+    """An expat parser that reads a DOCTYPE as REA does: one with an internal subset, which could declare entities,
+    is refused, the DTD it names is never read, and a reference to an entity other than XML's five is refused where
+    expat would skip it. With namespaces it also enforces their rules, as REA's parser does, and without them it
+    reports names as the document spells them. doctype, when given, receives the declared name and identifiers."""
+    parser = expat.ParserCreate(namespace_separator=" " if namespaces else None)
+    parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_NEVER)
+
+    def declared(name: str, system_id, public_id, internal_subset: bool) -> None:
+        if internal_subset:
+            raise ValueError("the document's DOCTYPE has an internal subset")
+        if doctype is not None:
+            doctype({"name": name, "public_id": public_id, "system_id": system_id})
+
+    def undeclared(name: str, _parameter: bool) -> None:
+        raise ValueError(f"the document refers to the undeclared entity {name}")
+
+    def external(*_) -> None:
+        raise ValueError("the document refers to an external entity")
+
+    parser.StartDoctypeDeclHandler = declared
+    parser.SkippedEntityHandler = undeclared
+    parser.ExternalEntityRefHandler = external
+    return parser
+
+
+def _check_tag(markup: str) -> None:
+    """expat leaves an undeclared entity out of an attribute value without a word when a DOCTYPE names a DTD; REA's
+    parser refuses it. With text taken by its own handler, a start tag is the only markup expat passes here that
+    starts with < and a name, and it passes it whole."""
+    if markup[:1] == "<" and markup[1:2] not in ("!", "?", "/"):
+        for name in ENTITY_REFERENCE.findall(markup):
+            if name not in PREDEFINED_ENTITIES:
+                raise ValueError(f"the document refers to the undeclared entity {name}")
+
+
+def _ignore_text(_text: str) -> None:
+    pass
+
+
+class _XmlReader:
+    """REA's XML view built as expat reads: names as spelled, declarations as attributes, text split where REA's DOM
+    splits it (an empty CDATA section joins the text around it), and each node counted against REA's limits."""
+
+    def __init__(self) -> None:
+        self.remaining, self.truncated, self.root, self.doctype = MAX_XML_NODES, False, None, None
+        #: Per open element: its view or None when left out, whether xml:space="preserve" applies inside it, whether
+        #: it holds an element, and whether it holds text other than whitespace: whitespace-only text is formatting
+        #: only in an element that holds elements and no such text.
+        self.open = []
+        self.text, self.cdata = [], None
+
+    def read(self, text: str) -> None:
+        parser = _expat(False, self._doctype)
+        parser.buffer_text = True
+        parser.StartElementHandler, parser.EndElementHandler = self._start, self._end
+        parser.CharacterDataHandler = self._data
+        parser.StartCdataSectionHandler, parser.EndCdataSectionHandler = self._cdata_start, self._cdata_end
+        parser.CommentHandler = parser.ProcessingInstructionHandler = self._other
+        parser.Parse(text, True)
+
+    def _doctype(self, declared: dict) -> None:
+        self.doctype = declared
+
+    def _admit(self) -> bool:
+        """Whether the next node inside a kept element is kept, within the node and depth limits; one past them
+        marks the view truncated."""
+        if self.open and self.open[-1][0] is None:
+            return False
+        if self.remaining <= 0 or len(self.open) > MAX_XML_DEPTH:
+            self.truncated = True
+            return False
+        self.remaining -= 1
+        return True
+
+    def _text_node(self, text: str) -> None:
+        if self.open and text.strip(XML_WHITESPACE):
+            self.open[-1][3] = True
+        if self._admit():
+            self.open[-1][0]["children"].append(text)
+
+    def _flush(self) -> None:
+        if self.text:
+            text, self.text = "".join(self.text), []
+            self._text_node(text)
+
+    def _data(self, text: str) -> None:
+        (self.text if self.cdata is None else self.cdata).append(text)
+
+    def _cdata_start(self) -> None:
+        self.cdata = []
+
+    def _cdata_end(self) -> None:
+        text, self.cdata = "".join(self.cdata), None
+        if text:
+            self._flush()
+            self._text_node(text)
+
+    def _other(self, *_) -> None:
+        """A comment or processing instruction, counted like any node and never kept."""
+        self._flush()
+        if self.open:
+            self._admit()
+
+    def _start(self, name: str, attributes: dict) -> None:
+        self._flush()
+        parent = self.open[-1] if self.open else [None, False, False, False]
+        parent[2] = True
+        view = {"name": name, "attributes": attributes, "children": []} if self._admit() else None
+        if view is not None and parent[0] is not None:
+            parent[0]["children"].append(view)
+        space = attributes.get(XML_SPACE)
+        self.open.append([view, space == "preserve" if space else parent[1], False, False])
+
+    def _end(self, _name: str) -> None:
+        self._flush()
+        view, preserve, holds_element, holds_text = self.open.pop()
+        if view is not None and holds_element and not holds_text and not preserve:
+            view["children"] = [child for child in view["children"]
+                                if not isinstance(child, str) or child.strip(XML_WHITESPACE)]
+        if not self.open:
+            self.root = view
+
+
+def _xml_view(text: str):
+    """REA's XML view, or None for a document REA's parser refuses: a pass with namespaces checks the document as REA's
+    parser does, then a pass without them reads names as spelled, as REA's view keeps them, and the DOCTYPE."""
+    reader = _XmlReader()
+    try:
+        check = _expat(True)
+        check.CharacterDataHandler, check.DefaultHandler = _ignore_text, _check_tag
+        check.Parse(text, True)
+        reader.read(text)
+    except (expat.ExpatError, ValueError):
+        return None
+    view = {"root": reader.root, "truncated": reader.truncated}
+    return view if reader.doctype is None else {"doctype": reader.doctype, **view}
+
+
+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()
+_LEVEL_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], _LEVEL_END)
+        if item is _LEVEL_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 _deeper_than(root, limit: int) -> bool:
+    """Whether a parsed JSON value nests deeper than a limit, as REA checks it: a value's depth is the number of
+    iterators open above it, one per nesting level, so no child list is copied."""
+    levels = [iter((root,))]
+    while levels:
+        item = next(levels[-1], _LEVEL_END)
+        if item is _LEVEL_END:
+            levels.pop()
+        elif len(levels) - 1 > limit:
+            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 RecursionError:
+            # Nesting too deep for Python to parse is far deeper than REA's view keeps.
+            return {"format": "json", "view": None, "error": JSON_TOO_DEEP}
+        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"}
+            if _deeper_than(view, MAX_JSON_VIEW_DEPTH):
+                return {"format": "json", "view": None, "error": JSON_TOO_DEEP}
+            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 data.startswith(ZIP_HEADER):
+        return _zip(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
+
+MAX_ZIP_ENTRIES = 1000
+MAX_ZIP_ENTRY_BYTES = 16 * 1024 * 1024
+MAX_ZIP_BYTES = 64 * 1024 * 1024
+MAX_ZIP_RATIO = 100
+ZIP_READ_CHUNK = 64 * 1024
+ZIP_END = b"PK\x05\x06"
+ZIP_CENTRAL = b"PK\x01\x02"
+ZIP64_LOCATOR = b"PK\x06\x07"
+ZIP64_END = b"PK\x06\x06"
+#: Formats an archive entry may have whose reader needs a tool, a worker or another archive opened.
+NOT_READ_INSIDE = ((SQLITE_HEADER, "sqlite", "a SQLite database"), (GVDB_HEADER, "dconf", "a dconf database"),
+                   (ZIP_HEADER, "zip", "an archive"))
+
+
+def _entry_view(name: str, data: bytes) -> dict:
+    """An archive entry's format and view by the rules a file's follow; a database or an archive inside is not
+    read."""
+    for header, form, inside in NOT_READ_INSIDE:
+        if data.startswith(header):
+            return {"format": form, "view": None, "error": f"{inside} inside an archive is not read"}
+    try:
+        text = data.decode("utf-8-sig") if b"\x00" not in data[:8192] else None
+    except UnicodeDecodeError:
+        text = None
+    if text is None:
+        return {"format": "binary", "view": None}
+    view = _text_view(name, text)
+    if view["format"] in ("json", "keyfile") and len(data) > MAX_PARSED_BYTES:
+        return {"format": view["format"], "view": None,
+                "error": "larger than the 4 MiB limit for JSON and key file views"}
+    return view
+
+
+def _zip_refusal(info, spent: int):
+    """Why an entry is not read, checked in REA's order, or None; spent is the archive's bytes read so far."""
+    if info.flag_bits & 0x1:
+        return "encrypted, so it is not read"
+    if info.compress_type not in (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED):
+        return f"compressed with method {info.compress_type}, which the view does not read"
+    if info.file_size > MAX_ZIP_ENTRY_BYTES:
+        return "larger than the 16 MiB an entry's view reads"
+    if info.file_size > MAX_ZIP_RATIO * info.compress_size:
+        return f"expands more than {MAX_ZIP_RATIO} times, so it is not read"
+    if spent + info.file_size > MAX_ZIP_BYTES:
+        return "past the 64 MiB read from one archive"
+    return None
+
+
+def _entry_bytes(archive, info):
+    """An entry's uncompressed bytes, or None when they fail its CRC-32 or are not exactly its declared size. Reading
+    stops one byte past that size, which data past a short declared size fills, and asks for a bounded chunk at a
+    time, which bounds what the decompressor expands per call, so a forged small size holds no more than that."""
+    probe = copy.copy(info)
+    probe.file_size = info.file_size + 1
+    data = bytearray()
+    try:
+        with archive.open(probe) as member:
+            while len(data) <= info.file_size:
+                chunk = member.read(min(probe.file_size - len(data), ZIP_READ_CHUNK))
+                if not chunk:
+                    break
+                data += chunk
+    except (zipfile.BadZipFile, zlib.error, EOFError, OSError, ValueError):
+        return None
+    return data if len(data) == info.file_size else None
+
+
+def _zip_entry(archive, info, refusal):
+    """One entry of a zip view: its name, size and digest, and its own format and view, or why it was not read."""
+    entry = {"name": info.filename, "size": info.file_size, "sha256": None, "format": None, "view": None,
+             "view_error": refusal}
+    if refusal is not None:
+        return entry
+    data = _entry_bytes(archive, info)
+    if data is None:
+        return {**entry, "view_error": "its compressed data is damaged"}
+    view = _entry_view(info.filename, data)
+    return {**entry, "sha256": hashlib.sha256(data).hexdigest(), "format": view["format"],
+            "view": view.get("view"), "view_error": view.get("error")}
+
+
+def _zip_end(file, size: int):
+    """Where an archive's central directory ends, how long it is and the offset it declares, from the last end
+    record whose comment reaches the end of the file and, when a Zip64 locator precedes it whatever that record
+    holds, the Zip64 one just before the locator; None without an end record, or when sentinels defer to a
+    Zip64 record that is missing."""
+    window = min(size, 22 + 0xFFFF)
+    file.seek(size - window)
+    tail = file.read(window)
+    at = tail.rfind(ZIP_END, 0, len(tail) - 18)
+    while at >= 0 and at + 22 + int.from_bytes(tail[at + 20:at + 22], "little") != len(tail):
+        at = tail.rfind(ZIP_END, 0, at + 3)
+    if at < 0:
+        return None
+    total, length, offset = struct.unpack_from("<HII", tail, at + 10)
+    end = size - window + at
+    record = end - 20 - 56
+    if record < 0:
+        return end, length, offset
+    file.seek(end - 20)
+    if file.read(4) != ZIP64_LOCATOR:
+        return end, length, offset
+    file.seek(record)
+    zip64 = file.read(56)
+    if len(zip64) == 56 and zip64[:4] == ZIP64_END:
+        length, offset = struct.unpack_from("<QQ", zip64, 40)
+        return record, length, offset
+    if total == 0xFFFF or 0xFFFFFFFF in (length, offset):
+        return None
+    return end, length, offset
+
+
+def _zip_unicode_path(raw: bytes, flags: int, extra: bytes):
+    """An Info-ZIP Unicode Path when zip.js uses it: version 1, no UTF-8 flag, and the CRC-32 of the stored name."""
+    at = 0
+    while at + 4 <= len(extra):
+        kind, length = struct.unpack_from("<HH", extra, at)
+        if kind == 0x7075:
+            data = extra[at + 4:at + 4 + length]
+            usable = (length >= 5 and len(data) == length and data[0] == 1 and not flags & 0x800
+                      and int.from_bytes(data[1:5], "little") == zlib.crc32(raw))
+            return data[5:] if usable else None
+        at += 4 + length
+    return None
+
+
+def _zip_ends_in_slash(raw: bytes, flags: int, extra: bytes):
+    """Whether an entry's name, as REA decodes it, ends in a slash; None when it must be UTF-8 and is not."""
+    utf8 = _zip_unicode_path(raw, flags, extra)
+    if utf8 is None and flags & 0x800:
+        utf8 = raw
+    if utf8 is None:
+        return raw.endswith(b"/")
+    try:
+        return utf8.decode("utf-8").endswith("/")
+    except UnicodeDecodeError:
+        return None
+
+
+def _zip_directory(file, size: int, keep: int):
+    """An archive's central directory read a record at a time, keeping the first file entries' records, as many as keep allows, and
+    counting the rest, as REA reads it: (start, declared offset, records, count), or None when it cannot be read.
+    Directories are told apart as zip.js tells them: a final slash, a Unix directory mode, or the MS-DOS attribute."""
+    located = _zip_end(file, size)
+    if located is None:
+        return None
+    end, length, declared = located
+    start = end - length
+    if start < 0:
+        return None
+    file.seek(start)
+    records, count, at = [], 0, start
+    while at < end:
+        fixed = file.read(46)
+        if at + 46 > end or len(fixed) < 46 or fixed[:4] != ZIP_CENTRAL:
+            return None
+        made_by, flags = struct.unpack_from("<H2xH", fixed, 4)
+        name_length, extra_length, comment_length = struct.unpack_from("<HHH", fixed, 28)
+        external = struct.unpack_from("<I", fixed, 38)[0]
+        rest = file.read(name_length + extra_length + comment_length)
+        at += 46 + name_length + extra_length + comment_length
+        if len(rest) < name_length + extra_length + comment_length or at > end:
+            return None
+        slash = _zip_ends_in_slash(rest[:name_length], flags, rest[name_length:name_length + extra_length])
+        if slash is None:
+            return None
+        if not (slash or (external >> 16) & 0o170000 == 0o040000 or (made_by >> 8 == 0 and external & 0x10)):
+            count += 1
+            if len(records) < keep:
+                records.append(fixed + rest)
+    return start, declared, records, count
+
+
+class _BoundedArchive(io.RawIOBase):
+    """An archive as zipfile reads it: its entries in place, then a directory of the kept records alone and end
+    records for them, so zipfile parses no more records than the view lists."""
+
+    def __init__(self, file, start: int, tail: bytes) -> None:
+        super().__init__()
+        self._file, self._start, self._tail, self._at = file, start, tail, 0
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return True
+
+    def tell(self) -> int:
+        return self._at
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        self._at = offset + (0, self._at, self._start + len(self._tail))[whence]
+        return self._at
+
+    def readinto(self, buffer) -> int:
+        view = memoryview(buffer)
+        if self._at < self._start:
+            self._file.seek(self._at)
+            count = self._file.readinto(view[:self._start - self._at])
+        else:
+            chunk = self._tail[self._at - self._start:self._at - self._start + len(view)]
+            count = len(chunk)
+            view[:count] = chunk
+        self._at += count
+        return count
+
+
+def _zip(path: Path) -> dict:
+    """A zip archive's file entries in archive order, up to REA's entry, size, ratio and archive limits; nothing is
+    extracted to disk, no archive inside is opened, and zipfile is shown only the directory records listed."""
+    entries, spent = [], 0
+    try:
+        with path.open("rb") as file:
+            directory = _zip_directory(file, os.fstat(file.fileno()).st_size, MAX_ZIP_ENTRIES)
+            if directory is None:
+                raise zipfile.BadZipFile("no readable central directory")
+            start, declared, records, count = directory
+            kept = b"".join(records)
+            offset = declared if declared <= 0xFFFFFFFF else start
+            # zipfile follows a Zip64 locator signature wherever one sits before the end record, and the kept records
+            # may end in those bytes, so a real Zip64 end record and locator for them come first.
+            tail = (kept
+                    + struct.pack("<4sQ2H2I4Q", ZIP64_END, 44, 45, 45, 0, 0, len(records), len(records), len(kept), offset)
+                    + struct.pack("<4sIQI", ZIP64_LOCATOR, 0, offset + len(kept), 1)
+                    + struct.pack("<4s4H2IH", ZIP_END, 0, 0, len(records), len(records), len(kept), offset, 0))
+            with zipfile.ZipFile(_BoundedArchive(file, start, tail)) as archive:
+                for info in archive.infolist():
+                    refusal = _zip_refusal(info, spent)
+                    spent += info.file_size if refusal is None else 0
+                    entries.append(_zip_entry(archive, info, refusal))
+    except (zipfile.BadZipFile, zlib.error, EOFError, NotImplementedError, OSError, ValueError, struct.error):
+        return {"format": "zip", "view": None, "error": "not a readable zip archive"}
+    view = {"entries": entries, "entry_count": count, "truncated": count > len(entries)}
+    return {"format": "zip", "view": view, "truncated": view["truncated"]}
+
+
+@computer_app(supports=[{"os": {"type": "linux", "display": ["x11"]}, "arch": ["amd64", "arm64"]}])
+@linux(
+    packages=Packages(apt=["gnumeric"]),
+    launch=Launch(at="boot", command=["sh", "-c", "cd \"$HOME\" 2>/dev/null; exec 'gnumeric' '--name' 'org.gnumeric.gnumeric' \"$HOME\"/'Documents/household-budget.xml'"], window={"class": "Gnumeric"}, ready=Ready(window=True)),
+    paths=PATHS,
+    skill="SKILL.md",
+)
+class Gnumeric(ComputerAppEnvironment):
+    """Gnumeric, 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/gnumeric/seed/Documents/household-budget.xml

@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gnm:Workbook xmlns:gnm="http://www.gnumeric.org/v10.dtd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.gnumeric.org/v9.xsd">
+  <gnm:Version Epoch="1" Major="12" Minor="56" Full="1.12.56"/>
+  <gnm:Attributes>
+    <gnm:Attribute>
+      <gnm:name>WorkbookView::show_horizontal_scrollbar</gnm:name>
+      <gnm:value>TRUE</gnm:value>
+    </gnm:Attribute>
+    <gnm:Attribute>
+      <gnm:name>WorkbookView::show_vertical_scrollbar</gnm:name>
+      <gnm:value>TRUE</gnm:value>
+    </gnm:Attribute>
+    <gnm:Attribute>
+      <gnm:name>WorkbookView::show_notebook_tabs</gnm:name>
+      <gnm:value>TRUE</gnm:value>
+    </gnm:Attribute>
+    <gnm:Attribute>
+      <gnm:name>WorkbookView::do_auto_completion</gnm:name>
+      <gnm:value>TRUE</gnm:value>
+    </gnm:Attribute>
+    <gnm:Attribute>
+      <gnm:name>WorkbookView::is_protected</gnm:name>
+      <gnm:value>FALSE</gnm:value>
+    </gnm:Attribute>
+  </gnm:Attributes>
+  <office:document-meta xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:ooo="http://openoffice.org/2004/office" office:version="1.2">
+    <office:meta>
+      <dc:date>2026-11-05T23:45:25Z</dc:date>
+      <meta:creation-date>2026-11-05T23:42:49Z</meta:creation-date>
+    </office:meta>
+  </office:document-meta>
+  <gnm:Calculation ManualRecalc="0" EnableIteration="1" MaxIterations="100" IterationTolerance="0.001" FloatRadix="2" FloatDigits="53"/>
+  <gnm:SheetNameIndex>
+    <gnm:SheetName gnm:Cols="256" gnm:Rows="65536">Sheet1</gnm:SheetName>
+  </gnm:SheetNameIndex>
+  <gnm:Geometry Width="960" Height="392"/>
+  <gnm:Sheets>
+    <gnm:Sheet DisplayFormulas="0" HideZero="0" HideGrid="0" HideColHeader="0" HideRowHeader="0" DisplayOutlines="1" OutlineSymbolsBelow="1" OutlineSymbolsRight="1" Visibility="GNM_SHEET_VISIBILITY_VISIBLE" GridColor="0:0:0">
+      <gnm:Name>Sheet1</gnm:Name>
+      <gnm:MaxCol>4</gnm:MaxCol>
+      <gnm:MaxRow>5</gnm:MaxRow>
+      <gnm:Zoom>1</gnm:Zoom>
+      <gnm:Names>
+        <gnm:Name>
+          <gnm:name>Print_Area</gnm:name>
+          <gnm:value>#REF!</gnm:value>
+          <gnm:position>A1</gnm:position>
+        </gnm:Name>
+        <gnm:Name>
+          <gnm:name>Sheet_Title</gnm:name>
+          <gnm:value>&quot;Sheet1&quot;</gnm:value>
+          <gnm:position>A1</gnm:position>
+        </gnm:Name>
+      </gnm:Names>
+      <gnm:PrintInformation>
+        <gnm:Margins>
+          <gnm:top Points="120" PrefUnit="mm"/>
+          <gnm:bottom Points="120" PrefUnit="mm"/>
+          <gnm:left Points="72" PrefUnit="mm"/>
+          <gnm:right Points="72" PrefUnit="mm"/>
+          <gnm:header Points="72" PrefUnit="mm"/>
+          <gnm:footer Points="72" PrefUnit="mm"/>
+        </gnm:Margins>
+        <gnm:Scale type="percentage" percentage="100"/>
+        <gnm:vcenter value="0"/>
+        <gnm:hcenter value="0"/>
+        <gnm:grid value="0"/>
+        <gnm:even_if_only_styles value="0"/>
+        <gnm:monochrome value="0"/>
+        <gnm:draft value="0"/>
+        <gnm:titles value="0"/>
+        <gnm:do_not_print value="0"/>
+        <gnm:print_range value="GNM_PRINT_ACTIVE_SHEET"/>
+        <gnm:order>d_then_r</gnm:order>
+        <gnm:orientation>portrait</gnm:orientation>
+        <gnm:Header Left="" Middle="&amp;[TAB]" Right=""/>
+        <gnm:Footer Left="" Middle="Page &amp;[PAGE]" Right=""/>
+        <gnm:paper>na_letter</gnm:paper>
+        <gnm:comments placement="GNM_PRINT_COMMENTS_IN_PLACE"/>
+        <gnm:errors PrintErrorsAs="GNM_PRINT_ERRORS_AS_DISPLAYED"/>
+      </gnm:PrintInformation>
+      <gnm:Styles>
+        <gnm:StyleRegion startCol="0" startRow="0" endCol="255" endRow="65535">
+          <gnm:Style HAlign="GNM_HALIGN_GENERAL" VAlign="GNM_VALIGN_BOTTOM" WrapText="0" ShrinkToFit="0" Rotation="0" Shade="0" Indent="0" Locked="1" Hidden="0" Fore="0:0:0" Back="FFFF:FFFF:FFFF" PatternColor="0:0:0" Format="General">
+            <gnm:Font Unit="10" Bold="0" Italic="0" Underline="0" StrikeThrough="0" Script="0">Sans</gnm:Font>
+          </gnm:Style>
+        </gnm:StyleRegion>
+      </gnm:Styles>
+      <gnm:Cols DefaultSizePts="60.75"/>
+      <gnm:Rows DefaultSizePts="13.5"/>
+      <gnm:Selections CursorCol="0" CursorRow="6">
+        <gnm:Selection startCol="0" startRow="6" endCol="0" endRow="6"/>
+      </gnm:Selections>
+      <gnm:Cells>
+        <gnm:Cell Row="0" Col="0" ValueType="60">Category</gnm:Cell>
+        <gnm:Cell Row="0" Col="1" ValueType="60">January</gnm:Cell>
+        <gnm:Cell Row="0" Col="2" ValueType="60">February</gnm:Cell>
+        <gnm:Cell Row="0" Col="3" ValueType="60">March</gnm:Cell>
+        <gnm:Cell Row="0" Col="4" ValueType="60">April</gnm:Cell>
+        <gnm:Cell Row="1" Col="0" ValueType="60">Rent</gnm:Cell>
+        <gnm:Cell Row="1" Col="1" ValueType="40">1450</gnm:Cell>
+        <gnm:Cell Row="1" Col="2" ValueType="40">1450</gnm:Cell>
+        <gnm:Cell Row="1" Col="3" ValueType="40">1450</gnm:Cell>
+        <gnm:Cell Row="1" Col="4" ValueType="40">1450</gnm:Cell>
+        <gnm:Cell Row="2" Col="0" ValueType="60">Groceries</gnm:Cell>
+        <gnm:Cell Row="2" Col="1" ValueType="40">412.35000000000002</gnm:Cell>
+        <gnm:Cell Row="2" Col="2" ValueType="40">398.19999999999999</gnm:Cell>
+        <gnm:Cell Row="2" Col="3" ValueType="40">405.10000000000002</gnm:Cell>
+        <gnm:Cell Row="2" Col="4" ValueType="40">421.75</gnm:Cell>
+        <gnm:Cell Row="3" Col="0" ValueType="60">Utilities</gnm:Cell>
+        <gnm:Cell Row="3" Col="1" ValueType="40">186.40000000000001</gnm:Cell>
+        <gnm:Cell Row="3" Col="2" ValueType="40">201.15000000000001</gnm:Cell>
+        <gnm:Cell Row="3" Col="3" ValueType="40">174.90000000000001</gnm:Cell>
+        <gnm:Cell Row="3" Col="4" ValueType="40">162.30000000000001</gnm:Cell>
+        <gnm:Cell Row="4" Col="0" ValueType="60">Transport</gnm:Cell>
+        <gnm:Cell Row="4" Col="1" ValueType="40">95</gnm:Cell>
+        <gnm:Cell Row="4" Col="2" ValueType="40">110</gnm:Cell>
+        <gnm:Cell Row="4" Col="3" ValueType="40">88.5</gnm:Cell>
+        <gnm:Cell Row="4" Col="4" ValueType="40">102</gnm:Cell>
+        <gnm:Cell Row="5" Col="0" ValueType="60">Total</gnm:Cell>
+        <gnm:Cell Row="5" Col="1" ExprID="1">=sum(B2:B5)</gnm:Cell>
+        <gnm:Cell Row="5" Col="2" ExprID="2">=sum(C2:C5)</gnm:Cell>
+        <gnm:Cell Row="5" Col="3" ExprID="3">=sum(D2:D5)</gnm:Cell>
+        <gnm:Cell Row="5" Col="4" ExprID="4">=sum(E2:E5)</gnm:Cell>
+      </gnm:Cells>
+      <gnm:SheetLayout TopLeft="A1"/>
+      <gnm:Solver ModelType="0" ProblemType="0" MaxTime="60" MaxIter="1000" NonNeg="1" Discr="0" AutoScale="0" ProgramR="0" SensitivityR="0"/>
+    </gnm:Sheet>
+  </gnm:Sheets>
+  <gnm:UIData SelectedTab="0"/>
+</gnm:Workbook>

bundle/evals/gnumeric.toml

@@ -0,0 +1 @@
+tasks = ["update-march-groceries"]

bundle/tasks/smoke.json

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

bundle/tasks/update-march-groceries.json

@@ -0,0 +1,9 @@
+[
+  {"id":"env","type":"deploy_env","env_id":"gnumeric"},
+  {"id":"agent","type":"deploy_agent","env_ids":["gnumeric"]},
+  {"id":"skills","type":"add_skills","env_ids":["gnumeric"]},
+  {"id":"record","type":"start_computer_recording","env_id":"gnumeric","name":"agent","depends_on":["env"]},
+  {"id":"task","type":"prompt_agent","depends_on":["skills","record"],"prompt":"In my household budget spreadsheet, Documents/household-budget.xml, change the Groceries figure for March to 437.80 and save it."},
+  {"id":"check","type":"env_outcome_verifier","env_id":"gnumeric","file_artifact_id":"update-march-groceries-check","verifier_id":"update-march-groceries","depends_on":["task"]},
+  {"id":"end","type":"end_computer_recording","name":"agent","depends_on":["task"]}
+]

media/solve-1.mp4

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

media/solve-2.mp4

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

media/solve-3.mp4

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

media/witness.mp4

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

results.json

@@ -0,0 +1,111 @@
+{
+  "environment": "Gnumeric",
+  "app_version": "Gnumeric 1.12 spreadsheet",
+  "task": "update-march-groceries",
+  "prompt": "In my household budget spreadsheet, Documents/household-budget.xml, change the Groceries figure for March to 437.80 and save it.",
+  "agent": "claude-code",
+  "model": "claude-sonnet-5-5",
+  "agentenv_framework": "0.9.1431",
+  "witness": "checks failed on the seed, passed after an edit made through computer actions, failed on a near miss (437.80 typed as 473.80) and failed again after data/reset, in a fresh computer; held on the first try",
+  "runs": [
+    {
+      "run": 1,
+      "verdict": "passed",
+      "turns": 10,
+      "usd": 0.43,
+      "checks": {
+        "update-march-groceries": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "march-groceries",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=3]/children/0 is \"437.80000000000001\", within 0.001 of 437.8"
+            },
+            {
+              "id": "february-groceries-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=2]/children/0 is \"398.19999999999999\", within 0.001 of 398.2"
+            },
+            {
+              "id": "april-groceries-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=4]/children/0 is \"421.75\", within 0.001 of 421.75"
+            },
+            {
+              "id": "march-utilities-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=3][@Col=3]/children/0 is \"174.90000000000001\", within 0.001 of 174.9"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 2,
+      "verdict": "passed",
+      "turns": 10,
+      "usd": 0.69,
+      "checks": {
+        "update-march-groceries": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "march-groceries",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=3]/children/0 is \"437.80000000000001\", within 0.001 of 437.8"
+            },
+            {
+              "id": "february-groceries-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=2]/children/0 is \"398.19999999999999\", within 0.001 of 398.2"
+            },
+            {
+              "id": "april-groceries-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=4]/children/0 is \"421.75\", within 0.001 of 421.75"
+            },
+            {
+              "id": "march-utilities-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=3][@Col=3]/children/0 is \"174.90000000000001\", within 0.001 of 174.9"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 3,
+      "verdict": "passed",
+      "turns": 10,
+      "usd": 0.45,
+      "checks": {
+        "update-march-groceries": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "march-groceries",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=3]/children/0 is \"437.80000000000001\", within 0.001 of 437.8"
+            },
+            {
+              "id": "february-groceries-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=2]/children/0 is \"398.19999999999999\", within 0.001 of 398.2"
+            },
+            {
+              "id": "april-groceries-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=2][@Col=4]/children/0 is \"421.75\", within 0.001 of 421.75"
+            },
+            {
+              "id": "march-utilities-untouched",
+              "result": true,
+              "description": "Documents/household-budget.xml at /root/children/[name=gnm:Sheets]/children/[name=gnm:Sheet]/children/[name=gnm:Cells]/children/[name=gnm:Cell][@Row=3][@Col=3]/children/0 is \"174.90000000000001\", within 0.001 of 174.9"
+            }
+          ]
+        }
+      }
+    }
+  ]
+}