REA computer-use environment, v0.1.0

README.md

@@ -0,0 +1,95 @@
+---
+license: apache-2.0
+pretty_name: Inkscape computer-use environment (REA)
+tags:
+- computer-use
+- cua
+- gui-agent
+- rl-environment
+- agentenv
+- desktop
+- linux
+- rea
+- vector-graphics
+- svg
+- design
+---
+
+# Inkscape: a computer-use environment
+
+![An agent solving the task in Inkscape](media/hero.gif)
+
+**The real Inkscape 1.2 vector graphics 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.**
+
+Inkscape opens a bake sale poster. The agent has to change the headline from Spring to Summer with Inkscape's text tool and save the drawing. 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 bake sale poster open in Inkscape, change the headline from "Spring Bake Sale" to "Summer Bake Sale", then save the poster.
+
+`bundle/artifacts/summer-headline-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 |
+| --- | --- | --- |
+| `headline` | `value_equals` | `Documents/poster.svg` |
+| `price-kept` | `value_equals` | `Documents/poster.svg` |
+| `date-kept` | `value_equals` | `Documents/poster.svg` |
+
+The checks read the saved SVG as XML. They find the text by its layer label and `id`, never by position. The headline must read "Summer Bake Sale" exactly, and the price and date lines must be unchanged.
+
+## Results
+
+3 of 3 runs passed, about $0.41 per run.
+
+| Run | Outcome | Turns | Cost | Video |
+| --- | --- | --- | --- | --- |
+| 1 | passed | 10 | $0.66 | [video](media/solve-1.mp4) |
+| 2 | passed | 10 | $0.41 | [video](media/solve-2.mp4) |
+| 3 | passed | 10 | $0.17 | [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 (`inkscape` 1.2.2).
+
+```bash
+pip install agentenv-framework==0.9.1431
+hf download earakely-scale/InkscapeComputerEnv-REA --repo-type dataset --local-dir inkscape
+agent-env run inkscape/bundle --task summer-headline --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 Inkscape 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 expect each line of text to stay one `tspan` inside its `text` element, in the layer labelled Layer 1. A correct-looking poster whose text was moved to another layer, ungrouped or split over two lines fails.
+- The headline must match exactly, so a stray double space fails.
+- The computer uses the `inkscape` 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. Inkscape itself is not included: the computer installs it from Ubuntu's archive (`inkscape` 1.2.2) at build time, under its own licence (GNU GPL).

bundle/README.md

@@ -0,0 +1,40 @@
+# Inkscape computer app
+
+Exported by REA's `export-desktop-application` from a capture of the `inkscape` package
+(capture Evidence `ev_c45a1b957a5bdf56e22a2cfb85f1a4dda39b4ef058c41d591f36273295ebddc7`). It was checked against agentenv-framework
+0.9.1431.
+
+- `envs/inkscape/` is a computer app on the `ubuntu-24.04` base with the `reference` driver, for
+  `amd64` and `arm64`. It installs `inkscape` from the distribution archive, launches `sh -c exec 'inkscape' "$HOME"/'Documents/poster.svg'` at boot and is ready
+  when a window of class `Inkscape` appears.
+- Owned paths: `~/.config/inkscape`, `~/Documents`.
+  `data/get` returns their files and a typed JSON view of each; `data/reset` restores the seed.
+- Seed: 3 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 `summer-headline`
+
+`tasks/summer-headline.json` deploys the app, has the agent work through the computer from the prompt below, and grades
+the outcome with `artifacts/summer-headline-check/verify.py`, which reads the app's `data/get` views and needs
+no model. `evals/inkscape.toml` names it, so a run of the bundle runs it.
+
+> In the bake sale poster open in Inkscape, change the headline from "Spring Bake Sale" to "Summer Bake Sale", then save the poster.
+
+Checks, each of which must pass:
+
+- `headline`: `{"kind":"value_equals","file":"Documents/poster.svg","pointer":"/root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=headline]/children/[name=tspan]/children/0","value":"Summer Bake Sale"}`
+- `price-kept`: `{"kind":"value_equals","file":"Documents/poster.svg","pointer":"/root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=price]/children/[name=tspan]/children/0","value":"All cakes $2"}`
+- `date-kept`: `{"kind":"value_equals","file":"Documents/poster.svg","pointer":"/root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=date]/children/[name=tspan]/children/0","value":"Saturday 14 March, 10am"}`
+
+REA kept the task because its checks fail on the seed (`headline`) 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 summer-headline --agent claude-code --model MODEL

bundle/artifacts/summer-headline-check/verify.py

@@ -0,0 +1,300 @@
+"""Checks of the task summer-headline against the inkscape 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 = "inkscape"
+CHECKS = [
+    {"id": "headline", "kind": "value_equals", "file": "Documents/poster.svg", "pointer": "/root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=headline]/children/[name=tspan]/children/0", "value": "Summer Bake Sale"},
+    {"id": "price-kept", "kind": "value_equals", "file": "Documents/poster.svg", "pointer": "/root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=price]/children/[name=tspan]/children/0", "value": "All cakes $2"},
+    {"id": "date-kept", "kind": "value_equals", "file": "Documents/poster.svg", "pointer": "/root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=date]/children/[name=tspan]/children/0", "value": "Saturday 14 March, 10am"},
+]
+
+MISSING = object()
+INDEX = re.compile(r"0|[1-9][0-9]*")
+NUMERAL = re.compile(r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?")
+
+
+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)."""
+    current = view
+    tokens = [raw.replace("~1", "/").replace("~0", "~") for raw in pointer[1:].split("/")]
+    for position, token in enumerate(tokens):
+        if isinstance(current, list):
+            kind, found = _step(current, token, position == len(tokens) - 1)
+            if kind != "member":
+                return kind, found
+            current = found
+        elif isinstance(current, dict) and token in current:
+            current = current[token]
+        else:
+            return "none", None
+    return "value", current
+
+
+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 _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 = ("none", None) if entry is None else _locate(view, check["pointer"])
+    at = f"{check['file']} at {check['pointer']}"
+    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 _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/inkscape/SKILL.md

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

bundle/envs/inkscape/env.toml

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

bundle/envs/inkscape/inkscape_app.py

@@ -0,0 +1,564 @@
+"""Inkscape as an agentenv computer app, exported by REA from a desktop application capture.
+
+Package: inkscape (captured at 1.2.2-2ubuntu12). Capture Evidence: ev_c45a1b957a5bdf56e22a2cfb85f1a4dda39b4ef058c41d591f36273295ebddc7.
+The seed is synthetic test data made for this showcase.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import json
+import math
+import os
+import re
+import sqlite3
+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
+CAPTURED_HOME = "/home/user"
+PATHS = [".config/inkscape", "Documents"]
+DCONF = ""
+TEXT_SEEDS = frozenset([".config/inkscape/extension-errors.log", ".config/inkscape/preferences.xml", "Documents/poster.svg"])
+WINDOW_CLASS = "Inkscape"
+
+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_ZIP_ENTRIES = 1000
+MAX_ZIP_ENTRY_BYTES = 16 * 1024 * 1024
+MAX_ZIP_BYTES = 64 * 1024 * 1024
+MAX_ZIP_RATIO = 100
+#: 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 _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
+
+
+def _expat(namespaces: bool):
+    """An expat parser that refuses DOCTYPEs as REA does; with namespaces it also enforces their rules, as REA's
+    parser does, and without them it reports names as the document spells them."""
+    parser = expat.ParserCreate(namespace_separator=" " if namespaces else None)
+
+    def doctype(*_) -> None:
+        raise ValueError("the document declares a DOCTYPE")
+
+    parser.StartDoctypeDeclHandler = doctype
+    return parser
+
+
+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 = MAX_XML_NODES, False, None
+        #: Per open element: its view or None when left out, whether xml:space="preserve" applies inside it, and
+        #: whether it holds an element, which makes whitespace-only text in it formatting.
+        self.open = []
+        self.text, self.cdata = [], None
+
+    def read(self, text: str) -> None:
+        parser = _expat(False)
+        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 _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._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]
+        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])
+
+    def _end(self, _name: str) -> None:
+        self._flush()
+        view, preserve, holds_element = self.open.pop()
+        if view is not None and holds_element and not preserve:
+            view["children"] = [child for child in view["children"] if not isinstance(child, str) or child.strip()]
+        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."""
+    reader = _XmlReader()
+    try:
+        _expat(True).Parse(text, True)
+        reader.read(text)
+    except (expat.ExpatError, ValueError):
+        return None
+    return {"root": reader.root, "truncated": reader.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 _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 _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
+    try:
+        with archive.open(info) as member:
+            data = member.read()
+    except (zipfile.BadZipFile, zlib.error, EOFError, OSError, ValueError):
+        data = None
+    if data is None or len(data) != info.file_size:
+        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(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 and no archive inside is opened."""
+    entries, count, spent = [], 0, 0
+    try:
+        with zipfile.ZipFile(path) as archive:
+            for info in archive.infolist():
+                if info.is_dir():
+                    continue
+                count += 1
+                if len(entries) >= MAX_ZIP_ENTRIES:
+                    continue
+                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):
+        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"]}
+
+
+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
+
+
+@computer_app(supports=[{"os": {"type": "linux", "display": ["x11"]}, "arch": ["amd64", "arm64"]}])
+@linux(
+    packages=Packages(apt=["inkscape"]),
+    launch=Launch(at="boot", command=["sh", "-c", "exec 'inkscape' \"$HOME\"/'Documents/poster.svg'"], window={"class": "Inkscape"}, ready=Ready(window=True)),
+    paths=PATHS,
+    skill="SKILL.md",
+)
+class Inkscape(ComputerAppEnvironment):
+    """Inkscape, 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/inkscape/seed/.config/inkscape/extension-errors.log

@@ -0,0 +1,42 @@
+Extension "XFIG Input" failed to load because a dependency was not met.
+Dependency:
+	type: executable
+	location: path
+	string: fig2dev
+
+Extension "Export to PDF via Scribus" failed to load because a dependency was not met.
+Dependency:
+	type: executable
+	location: path
+	string: scribus
+
+Extension "GIMP XCF" failed to load because a dependency was not met.
+Dependency:
+	type: executable
+	location: path
+	string: gimp
+
+Extension "Formula (pdflatex)" failed to load because a dependency was not met.
+Dependency:
+	type: executable
+	location: path
+	string: pdflatex
+
+Extension "PostScript Input" failed to load because a dependency was not met.
+Dependency:
+	type: executable
+	location: path
+	string: ps2pdf
+
+Extension "Optimized PNG" failed to load because a dependency was not met.
+Dependency:
+	type: executable
+	location: path
+	string: optipng
+
+Extension "EPS Input" failed to load because a dependency was not met.
+Dependency:
+	type: executable
+	location: path
+	string: ps2pdf
+

bundle/envs/inkscape/seed/.config/inkscape/preferences.xml

@@ -0,0 +1,493 @@
+
+<inkscape version="1"
+  xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+  xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">
+  <group id="window">
+    <group id="menu"        state="1"/>
+    <group id="commands"    state="1"/>
+    <group id="snaptoolbox" state="1"/>
+    <group id="toppanel"    state="1"/>
+    <group id="toolbox"     state="1"/>
+    <group id="statusbar"   state="1"/>
+    <group id="panels"      state="1"/>
+    <group id="rulers"      state="1"/>
+    <group id="scrollbars"  state="1"/>
+  </group>
+  <group id="fullscreen">
+    <group id="menu"        state="1"/>
+    <group id="commands"    state="1"/>
+    <group id="snaptoolbox" state="1"/>
+    <group id="toppanel"    state="1"/>
+    <group id="toolbox"     state="1"/>
+    <group id="statusbar"   state="1"/>
+    <group id="panels"      state="1"/>
+    <group id="rulers"      state="1"/>
+    <group id="scrollbars"  state="1"/>
+  </group>
+  <group id="focus">
+    <group id="menu"        state="0"/>
+    <group id="commands"    state="0"/>
+    <group id="snaptoolbox" state="0"/>
+    <group id="toppanel"    state="0"/>
+    <group id="toolbox"     state="0"/>
+    <group id="statusbar"   state="0"/>
+    <group id="panels"      state="0"/>
+    <group id="rulers"      state="0"/>
+    <group id="scrollbars"  state="0"/>
+  </group>
+
+  <group id="template">
+    <sodipodi:namedview
+       id="base"
+       pagecolor="#ffffff"
+       pageopacity="0.0"
+       pagecheckerboard="0"
+       bordercolor="#000000"
+       borderopacity="0.25"
+       objecttolerance="10.0"
+       gridtolerance="10.0"
+       guidetolerance="10.0"
+       pageshadow="2" />
+  </group>
+
+  <group id="tools" bounding_box="0">
+
+    <group id="shapes" style="fill-rule:evenodd;" selcue="1" gradientdrag="1">
+      <eventcontext id="rect" style="fill:blue;" usecurrent="1"/>
+      <eventcontext id="3dbox" style="stroke:none;stroke-linejoin:round;" usecurrent="1">
+        <side id="XYfront"  style="fill:#8686bf;stroke:none;stroke-linejoin:round;" usecurrent="0"/>
+        <side id="XYrear"   style="fill:#e9e9ff;stroke:none;stroke-linejoin:round;" usecurrent="0"/>
+        <side id="XZtop"    style="fill:#4d4d9f;stroke:none;stroke-linejoin:round;" usecurrent="0"/>
+        <side id="XZbottom" style="fill:#afafde;stroke:none;stroke-linejoin:round;" usecurrent="0"/>
+        <side id="YZright"  style="fill:#353564;stroke:none;stroke-linejoin:round;" usecurrent="0"/>
+        <side id="YZleft"   style="fill:#d7d7ff;stroke:none;stroke-linejoin:round;" usecurrent="0"/>
+      </eventcontext>
+      <eventcontext id="arc" style="fill:red;" end="0" start="0" usecurrent="1"/>
+      <eventcontext id="star" magnitude="5" style="fill:yellow;" usecurrent="1"/>
+      <eventcontext id="spiral" style="fill:none;stroke:black" expansion="1" usecurrent="0"/>
+    </group>
+
+    <group id="freehand"
+         style="fill:none;stroke:black;stroke-opacity:1;stroke-linejoin:miter;stroke-linecap:butt;">
+      <eventcontext id="pencil" tolerance="15.0" selcue="1" style="stroke-width:1px;" usecurrent="1" average_all_sketches="1"/>
+      <eventcontext id="pen" mode="drag" selcue="1" style="stroke-width:1px;" usecurrent="1"/>
+    </group>
+
+    <eventcontext id="calligraphic" style="fill:black;fill-opacity:1;fill-rule:nonzero;stroke:none;"
+                       mass="2" angle="30" width="15.118" thinning="10" flatness="-90" cap_rounding="0.0" usecurrent="1"
+                       tracebackground="0" usepressure="1" usetilt="0" keep_selected="1" abs_width="1" unit="mm">
+
+      <group id="preset">
+        <group id="cp0" name="Dip pen" mass="2" wiggle="0.0" angle="30.0" thinning="10" tremor="0.0" flatness="-90" cap_rounding="0.0" tracebackground="0" usepressure="1" usetilt="1" />
+        <group id="cp1" name="Marker" mass="2" wiggle="0.0" angle="90.0" thinning="0.0" tremor="0.0" flatness="0.0" cap_rounding="1.0" tracebackground="0" usepressure="0" usetilt="0" />
+        <group id="cp2" name="Brush" mass="2" wiggle="25" angle="45.0" thinning="-40" tremor="0.0" flatness="16" cap_rounding=".1" tracebackground="0" usepressure="1" usetilt="1" />
+        <group id="cp3" name="Wiggly" usetilt="1" tracebackground="0" usepressure="1" cap_rounding="0.1" flatness="16" tremor="18" thinning="-30" angle="30" wiggle="50" mass="0" />
+        <group id="cp4" name="Splotch" width="100" usetilt="1" tracebackground="0" usepressure="0" cap_rounding="1" flatness="0" tremor="10" thinning="30" angle="30" wiggle="0" mass="0" />
+        <group id="cp5" name="Tracing" width="50" mass="0" wiggle="0.0" angle="0.0" thinning="0.0" tremor="0.0" flatness="0" cap_rounding="0.0" tracebackground="1" usepressure="1" usetilt="1"/>
+      </group>
+    </eventcontext>
+
+    <eventcontext id="eraser" mode="1" style="fill:#ff0000;fill-opacity:1;fill-rule:nonzero;stroke:none;"
+                       mass="3.00" drag="1" angle="30" width="10" thinning="0.1" flatness="0.0" cap_rounding="1.4" usecurrent="0"
+                       tracebackground="0" usepressure="1" usetilt="0" selcue="1">
+    </eventcontext>
+
+    <eventcontext id="lpetool" mode="drag" style="fill:#ff0000;fill-opacity:1;fill-rule:nonzero;stroke:none;">
+    </eventcontext>
+
+    <eventcontext id="text"  usecurrent="1" gradientdrag="1"
+                       font_sample="AaBbCcIiPpQq12369$€¢?.;/()"
+                       show_sample_in_list="1" use_svg2="1"
+                  style="fill:black;fill-opacity:1;line-height:1.25;stroke:none;font-family:sans-serif;font-style:normal;font-weight:normal;font-size:40px;" selcue="1"/>
+
+    <eventcontext id="nodes" selcue="1" gradientdrag="1"
+      pathflash_enabled="1" pathflash_unselected="0" pathflash_timeout="500" show_handles="1" show_outline="0"
+      sculpting_profile="1" single_node_transform_handles="0" show_transform_handles="0" live_outline="1" live_objects="1" show_helperpath="0" x="0" y="0" edit_clipping_paths="0" edit_masks="0" />
+    <eventcontext id="marker" selcue="1" gradientdrag="1" />
+    <eventcontext id="tweak" selcue="0" gradientdrag="0" show_handles="0" width="0.2" force="0.2" fidelity="0.5" usepressure="1" style="fill:red;stroke:none;" usecurrent="1"/>
+    <eventcontext id="spray" selcue="1" gradientdrag="0" usepressure="1" width="15" population="70" mode="1" rotation_variation="0" scale_variation="0" standard_deviation="70" mean="0"/>
+    <eventcontext id="gradient" selcue="1"/>
+    <eventcontext id="mesh" selcue="1"/>
+    <eventcontext id="zoom" selcue="1" gradientdrag="0"/>
+    <eventcontext id="dropper" selcue="1" gradientdrag="1" pick="1" setalpha="1"/>
+    <eventcontext id="select" selcue="1" gradientdrag="0"/>
+    <eventcontext id="connector" style="fill:none;fill-rule:evenodd;stroke:black;stroke-opacity:1;stroke-linejoin:miter;stroke-width:1px;stroke-linecap:butt;" selcue="1"/>
+    <eventcontext id="paintbucket" style="fill:#a0a0a0;stroke:none;" usecurrent="1"/>
+    <group
+       id="geometric"
+       mode="drag" />
+  </group>
+
+  <group id="palette">
+    <group id="dashes">
+      <dash id="solid" style="stroke-dasharray:none"/>
+      <dash id="dash-1-1" style="stroke-dasharray:1,1"/>
+      <dash id="dash-1-2" style="stroke-dasharray:1,2"/>
+      <dash id="dash-1-3" style="stroke-dasharray:1,3"/>
+      <dash id="dash-1-4" style="stroke-dasharray:1,4"/>
+      <dash id="dash-1-6" style="stroke-dasharray:1,6"/>
+      <dash id="dash-1-8" style="stroke-dasharray:1,8"/>
+      <dash id="dash-1-12" style="stroke-dasharray:1,12"/>
+      <dash id="dash-1-24" style="stroke-dasharray:1,24"/>
+      <dash id="dash-1-48" style="stroke-dasharray:1,48"/>
+      <dash id="dash-empty" style="stroke-dasharray:0 11"/>
+      <dash id="dash-2-1" style="stroke-dasharray:2,1"/>
+      <dash id="dash-3-1" style="stroke-dasharray:3,1"/>
+      <dash id="dash-4-1" style="stroke-dasharray:4,1"/>
+      <dash id="dash-6-1" style="stroke-dasharray:6,1"/>
+      <dash id="dash-8-1" style="stroke-dasharray:8,1"/>
+      <dash id="dash-12-1" style="stroke-dasharray:12,1"/>
+      <dash id="dash-24-1" style="stroke-dasharray:24,1"/>
+      <dash id="dash-2-2" style="stroke-dasharray:2,2"/>
+      <dash id="dash-3-3" style="stroke-dasharray:3,3"/>
+      <dash id="dash-4-4" style="stroke-dasharray:4,4"/>
+      <dash id="dash-6-6" style="stroke-dasharray:6,6"/>
+      <dash id="dash-8-8" style="stroke-dasharray:8,8"/>
+      <dash id="dash-12-12" style="stroke-dasharray:12,12"/>
+      <dash id="dash-24-24" style="stroke-dasharray:24,24"/>
+      <dash id="dash-2-4" style="stroke-dasharray:2,4"/>
+      <dash id="dash-4-2" style="stroke-dasharray:4,2"/>
+      <dash id="dash-2-6" style="stroke-dasharray:2,6"/>
+      <dash id="dash-6-2" style="stroke-dasharray:6,2"/>
+      <dash id="dash-4-8" style="stroke-dasharray:4,8"/>
+      <dash id="dash-8-4" style="stroke-dasharray:8,4"/>
+      <dash id="dash-2-1-012-1" style="stroke-dasharray:2,1,0.5,1"/>
+      <dash id="dash-4-2-1-2" style="stroke-dasharray:4,2,1,2"/>
+      <dash id="dash-8-2-1-2" style="stroke-dasharray:8,2,1,2"/>
+      <dash id="dash-012-012" style="stroke-dasharray:0.5,0.5"/>
+      <dash id="dash-014-014" style="stroke-dasharray:0.25,0.25"/>
+      <dash id="dash-0110-0110" style="stroke-dasharray:0.1,0.1"/>
+    </group>
+  </group>
+
+  <group id="colorselector" page="0" switcher="1" />
+
+  <group id="embedded">
+    <group id="swatches"
+      panel_size="1"
+      panel_mode="1"
+      panel_ratio="100"
+      panel_wrap="0"
+      palette="Inkscape default" />
+  </group>
+
+  <group id="dialogs">
+    <group id="toolbox"/>
+    <group id="fillstroke"/>
+    <group id="filtereffects"/>
+    <group id="textandfont"/>
+    <group id="transformation" applyseparately="0"/>
+    <group id="align"/>
+    <group id="xml" h="500" w="300" />
+    <group id="find"/>
+    <group id="spellcheck" w="200" h="250" ignorenumbers="1"/>
+    <group id="documentoptions" state="1"/>
+    <group id="preferences" state="1"/>
+    <group id="gradienteditor"/>
+    <group id="object"/>
+    <group id="export" default="" append_extension="1" path="">
+      <group id="exportarea"/>
+      <group id="defaultxdpi"/>
+    </group>
+    <group id="save_as" default="" append_extension="1" enable_preview="1" path="" use_current_dir="1"/>
+    <group id="save_copy" default="" append_extension="1" enable_preview="1" path=""/>
+    <group id="open" enable_preview="1" path=""/>
+    <group id="import" enable_preview="1" path="" ask="1" ask_svg="1" link="link" scale="optimizeSpeed"/>
+    <group id="debug" redirect="0"/>
+    <group id="clonetiler" dotrace="0" />
+    <group id="gridtiler" />
+    <group id="extension-error" show-on-startup="0"/>
+    <group id="memory" />
+    <group id="messages" />
+    <group id="swatches" />
+    <group id="iconpreview" />
+    <group id="aboutextensions" />
+    <group id="treeeditor" />
+    <group id="layers" maxDepth="20" w="200" h="300" />
+    <group id="trace" state="1" />
+    <group id="script" />
+    <group id="input" />
+    <group id="colorpickerwindow" />
+    <group id="undo-history" />
+  </group>
+  <group id="printing">
+    <settings id="ps"/>
+    <group id="debug" add-label-comments="0"/>
+  </group>
+
+  <group id="options"
+     rotationlock="1">
+    <group id="renderingcache" size="512" />
+    <group id="useoldpdfexporter" value="0" />
+    <group id="highlightoriginal" value="1" />
+    <group id="relinkclonesonduplicate" value="0" />
+    <group id="mapalt" value="1" />
+    <group id="trackalt" value="0" />
+    <group id="switchonextinput" value="0" />
+    <group id="useextinput" value="1" />
+    <group id="nudgedistance" value="2px"/>
+    <group id="rotationsnapsperpi" value="12"/>
+    <group id="cursortolerance" value="8.0"/>
+    <group id="dragtolerance" value="4.0"/>
+    <group id="grabsize" value="4"/>
+    <group
+       id="displayprofile"
+       enable="0"
+       from_display="0"
+       intent="0"
+       uri="" />
+    <group
+       id="softproof"
+       enable="0"
+       intent="0"
+       gamutcolor="#808080"
+       gamutwarn="0"
+       bpc="0"
+       preserveblack="0"
+       uri="" />
+    <group id="savewindowgeometry" value="1"/>
+    <group id="defaultoffsetwidth" value="2px"/>
+    <group id="defaultscale" value="2px"/>
+    <group id="maxrecentdocuments" value="36"/>
+    <group id="zoomincrement" value="1.414213562"/>
+    <group id="zoomcorrection" value="1.0" unit="mm"/>
+    <group id="keyscroll" value="15"/>
+    <group id="wheelscroll" value="40"/>
+    <group id="spacebarpans" value="1"/>
+    <group id="transientpolicy" value="1"/>
+    <group id="scrollingacceleration" value="0.4"/>
+    <group id="snapdelay" value="0"/>
+    <group id="snapweight" value="0.5"/>
+    <group id="snapclosestonly" value="0"/>
+    <group id="snapindicator" value="1"/>
+    <group id="autoscrollspeed" value="0.7"/>
+    <group id="autoscrolldistance" value="-10"/>
+    <group id="simplifythreshold" value="0.002"/>
+    <group id="bitmapeditor" value="gimp"/>
+    <group id="svgeditor" value="inkscape"/>
+    <group id="bitmapautoreload" value="1"/>
+    <group id="dialogtype" value="1"/>
+    <group id="dialogsskiptaskbar" value="1"/>
+    <group id="defaultwindowsize" value="2" />
+    <group id="arenatilescachesize" value="8192"/>
+    <group id="preservetransform" value="0"/>
+    <group id="clonecompensation" value="1"/>
+    <group id="cloneorphans" value="0"/>
+    <group id="stickyzoom" value="0"/>
+    <group id="selcue" value="2"/>
+    <group id="transform" stroke="1" rectcorners="1" pattern="1" gradient="1" />
+    <group id="dash" scale="1" />
+    <group id="kbselection" inlayer="1" onlyvisible="1" onlysensitive="1" />
+    <group id="selection" layerdeselect="1" />
+    <group id="createbitmap"/>
+    <group id="compassangledisplay" value="0"/>
+    <group id="middlemousezoom" value="1"/>
+    <group id="maskobject" topmost="1" remove="1"/>
+    <group id="blurquality" value="0"/>
+    <group id="filterquality" value="1"/>
+    <group id="showfiltersinfobox" value="1" />
+    <group id="startmode" outline="0"/>
+    <group id="outlinemode" value="0"/>
+
+    <group id="wireframecolors"
+           onlight="255"
+           ondark="4294967295"
+           images="4278190335"
+           clips="16711935"
+           masks="65535"/>
+    <group id="svgoutput"
+           disable_optimizations="0"
+           usenamedcolors="0"
+           numericprecision="8"
+           minimumexponent="-8"
+           inlineattrs="0"
+           indent="2"
+           pathstring_format="2"
+           forcerepeatcommands="0"
+           incorrect_attributes_warn="1"
+           incorrect_attributes_remove="0"
+           incorrect_style_properties_warn="1"
+           incorrect_style_properties_remove="0"
+           style_defaults_warn="1"
+           style_defaults_remove="0"
+           check_on_reading="0"
+           check_on_editing="0"
+           check_on_writing="0"
+           sort_attributes="0"/>
+    <group id="externalresources">
+      <group id="xml"
+           allow_net_access="0"/>
+    </group>
+    <group id="forkgradientvectors" value="1"/>
+    <group id="iconrender" named_nodelay="0"/>
+    <group id="autosave" enable="1" interval="10" path="" max="50"/>
+    <group id="grids"
+      no_emphasize_when_zoomedout="0">
+      <group id="xy"
+             units="px"
+             origin_x="0.0"
+             origin_y="0.0"
+             spacing_x="1.0"
+             spacing_y="1.0"
+             empspacing="5"
+             dotted="0"/>
+      <group id="axonom"
+             units="mm"
+             origin_x="0.0"
+             origin_y="0.0"
+             spacing_y="1.0"
+             angle_x="30.0"
+             angle_z="30.0"
+             empspacing="5"/>
+    </group>
+    <group id="workarounds"
+           colorsontop="0"
+           partialdynamic="0"/>
+    <group
+       id="font"
+       unitType="2" />
+    <group
+       id="boot"
+       theme="colorful" />
+  </group>
+
+  <group
+     id="extensions"
+     org.inkscape.output.png.inkscape.png_bitdepth="99"
+     org.inkscape.output.png.inkscape.png_compression="6"
+     org.inkscape.output.png.inkscape.png_antialias="2" />
+
+  <group id="desktop"
+         style="fill:#000000">
+    <group
+       width="640"
+       height="480"
+       x="0"
+       y="0"
+       maximized="1"
+       fullscreen="0"
+       id="geometry" />
+    <group
+       id="XYfront" />
+    <group
+       id="XYrear" />
+    <group
+       id="XZtop" />
+    <group
+       id="XZbottom" />
+    <group
+       id="YZleft" />
+    <group
+       id="YZright" />
+  </group>
+
+  <group id="devices">
+  </group>
+
+  <group
+     id="toolbox"
+     icononly="1"
+     secondary="1"
+     simplesnap="1"
+     small="1">
+    <group
+       id="tools"
+       icononly="1"
+       small="0"
+       iconsize="16">
+      <group
+         id="buttons" />
+    </group>
+    <group
+       id="controlbars"
+       iconsize="16" />
+  </group>
+
+  <group
+     id="statusbar">
+    <group
+       id="visibility" />
+  </group>
+
+  <group
+     id="iconpreview"
+     autoRefresh="1"
+     pack="1"
+     selectionHold="1"
+     showFrames="1"
+     selectionOnly="0">
+    <group
+       id="sizes">
+      <group
+         id="default">
+        <group
+           value="16"
+           show="1"
+           id="size16" />
+        <group
+           value="22"
+           show="0"
+           id="size22" />
+        <group
+           value="24"
+           show="1"
+           id="size24" />
+        <group
+           value="32"
+           show="1"
+           id="size32" />
+        <group
+           value="48"
+           show="1"
+           id="size48" />
+        <group
+           value="50"
+           show="0"
+           id="size50" />
+        <group
+           value="64"
+           show="0"
+           id="size64" />
+        <group
+           value="72"
+           show="0"
+           id="size72" />
+        <group
+           value="80"
+           show="0"
+           id="size80" />
+        <group
+           value="96"
+           show="0"
+           id="size96" />
+        <group
+           value="128"
+           show="1"
+           id="size128" />
+        <group
+           value="256"
+           show="0"
+           id="size256" />
+      </group>
+    </group>
+  </group>
+  <group id="debug">
+    <group id="latency" skew="1"/>
+  </group>
+  <group id="ui"
+    language=""/>
+  <group
+     id="live_effects"
+     flattening="0" />
+  <group
+     id="theme"
+     defaultPreferDarkTheme="1"
+     defaultIconTheme="multicolor"
+     defaultGtkTheme="Adwaita"
+     narrowSpinButton="1"
+     preferDarkTheme="1"
+     darkTheme="1"
+     symbolicIcons="1"
+     symbolicDefaultBaseColors="1"
+     symbolicDefaultHighColors="0"/>
+</inkscape>

bundle/evals/inkscape.toml

@@ -0,0 +1 @@
+tasks = ["summer-headline"]

bundle/tasks/smoke.json

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

bundle/tasks/summer-headline.json

@@ -0,0 +1,9 @@
+[
+  {"id":"env","type":"deploy_env","env_id":"inkscape"},
+  {"id":"agent","type":"deploy_agent","env_ids":["inkscape"]},
+  {"id":"skills","type":"add_skills","env_ids":["inkscape"]},
+  {"id":"record","type":"start_computer_recording","env_id":"inkscape","name":"agent","depends_on":["env"]},
+  {"id":"task","type":"prompt_agent","depends_on":["skills","record"],"prompt":"In the bake sale poster open in Inkscape, change the headline from \"Spring Bake Sale\" to \"Summer Bake Sale\", then save the poster."},
+  {"id":"check","type":"env_outcome_verifier","env_id":"inkscape","file_artifact_id":"summer-headline-check","verifier_id":"summer-headline","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:65d012b653dd6ce0d0ae1fabe8cb53162859de48755e28ff265aaea8e7b4e9d1
+size 620423

media/solve-2.mp4

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

media/solve-3.mp4

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

media/witness.mp4

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

results.json

@@ -0,0 +1,96 @@
+{
+  "environment": "Inkscape",
+  "app_version": "Inkscape 1.2 vector graphics editor",
+  "task": "summer-headline",
+  "prompt": "In the bake sale poster open in Inkscape, change the headline from \"Spring Bake Sale\" to \"Summer Bake Sale\", then save the poster.",
+  "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": 10,
+      "usd": 0.66,
+      "checks": {
+        "summer-headline": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "headline",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=headline]/children/[name=tspan]/children/0 is \"Summer Bake Sale\""
+            },
+            {
+              "id": "price-kept",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=price]/children/[name=tspan]/children/0 is \"All cakes $2\""
+            },
+            {
+              "id": "date-kept",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=date]/children/[name=tspan]/children/0 is \"Saturday 14 March, 10am\""
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 2,
+      "verdict": "passed",
+      "turns": 10,
+      "usd": 0.41,
+      "checks": {
+        "summer-headline": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "headline",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=headline]/children/[name=tspan]/children/0 is \"Summer Bake Sale\""
+            },
+            {
+              "id": "price-kept",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=price]/children/[name=tspan]/children/0 is \"All cakes $2\""
+            },
+            {
+              "id": "date-kept",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=date]/children/[name=tspan]/children/0 is \"Saturday 14 March, 10am\""
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 3,
+      "verdict": "passed",
+      "turns": 10,
+      "usd": 0.17,
+      "checks": {
+        "summer-headline": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "headline",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=headline]/children/[name=tspan]/children/0 is \"Summer Bake Sale\""
+            },
+            {
+              "id": "price-kept",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=price]/children/[name=tspan]/children/0 is \"All cakes $2\""
+            },
+            {
+              "id": "date-kept",
+              "result": true,
+              "description": "Documents/poster.svg at /root/children/[name=g][@inkscape:label=Layer 1]/children/[name=text][@id=date]/children/[name=tspan]/children/0 is \"Saturday 14 March, 10am\""
+            }
+          ]
+        }
+      }
+    }
+  ]
+}