REA computer-use environment, v0.1.0

README.md

@@ -0,0 +1,111 @@
+---
+license: apache-2.0
+pretty_name: Osmo computer-use environment from a one-line request (REA)
+tags:
+- computer-use
+- cua
+- gui-agent
+- rl-environment
+- agentenv
+- desktop
+- linux
+- rea
+- personal-organizer
+- address-book
+- contacts
+- from-request
+---
+
+# Osmo: a computer-use environment built from a one-line request
+
+![An agent solving the task in Osmo](media/hero.gif)
+
+**The real Osmo 0.4 personal organizer 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. Osmo starts on its calendar, with an address book of three synthetic contacts. The agent has to add a fourth, Delphine Moreau, with her cell phone and e-mail. There is no file to open and nothing to save: Osmo writes its contacts to `~/.local/share/osmo/contacts_records.xml` after every change. 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 Osmo, add a new contact to my address book: Delphine Moreau, cell phone 555-0163, e-mail delphine.moreau@example.com.
+
+`bundle/artifacts/add-contact-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 |
+| --- | --- | --- |
+| `name` | `text_contains` | `.local/share/osmo/contacts_records.xml` |
+| `phone` | `text_contains` | `.local/share/osmo/contacts_records.xml` |
+| `email` | `text_contains` | `.local/share/osmo/contacts_records.xml` |
+| `kept` | `text_contains` | `.local/share/osmo/contacts_records.xml` |
+
+Osmo's contacts file is XML whose records have no attributes, so no selector can pick out one record. The checks read the whole address book's text with `text_contains`: it must hold "DelphineMoreau" (Osmo writes the first and last names next to each other), "555-0163" and "delphine.moreau@example.com", and must still hold Hannah Okafor's e-mail, so overwriting her contact instead of adding a new one fails. REA's draft suggested no checks for this file; Claude Code wrote these after reading the file in a throwaway export.
+
+## Results
+
+3 of 3 runs passed, about $0.99 per run.
+
+| Run | Outcome | Turns | Cost | Video |
+| --- | --- | --- | --- | --- |
+| 1 | passed | 17 | $1.19 | [video](media/solve-1.mp4) |
+| 2 | passed | 17 | $0.96 | [video](media/solve-2.mp4) |
+| 3 | passed | 20 | $0.81 | [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 (`osmo` 0.4.4).
+
+```bash
+pip install agentenv-framework==0.9.1431
+hf download earakely-scale/OsmoFromRequestComputerEnv-REA --repo-type dataset --local-dir osmo-request
+agent-env run osmo-request/bundle --task add-contact --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 an Osmo environment where the agent adds a new contact to the address book.
+
+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 Osmo 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 contact was added through computer actions alone, and the checks were read at four stages. They held on the first try:
+
+| Stage | Checks |
+| --- | --- |
+| `seed` | fail, as expected: the name, phone and e-mail are absent; the existing contact check passes |
+| `after_edit` | pass |
+| `near_miss` | fail, as expected: the new contact's phone was edited to 555-0136 |
+| `after_reset` | fail, as expected: `data/reset` restored the seed and Osmo relaunched on it |
+
+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 the address book as one run of text with no separators, so they cannot prove that the phone and e-mail belong to Delphine's record rather than another contact's. Only Hannah Okafor's contact is checked as kept, so overwriting one of the other two still passes.
+- The prompt has no save step: Osmo saves after every change, a setting the seed keeps.
+- The seed also holds Osmo's settings, an empty `lockfile` and WebKit storage files, which the capture picked up. Osmo started cleanly in the witness and in every run.
+- The computer installs whatever `osmo` Ubuntu 24.04's archive holds at build time (0.4.4 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. Osmo itself is not included: the computer installs it from Ubuntu's archive (`osmo` 0.4.4) at build time, under its own licence (GPL-2.0-or-later).

bundle/README.md

@@ -0,0 +1,42 @@
+# Osmo computer app
+
+Exported by REA's `export-desktop-application` from a capture of the `osmo` package
+(capture Evidence `ev_b5f9fb22877191be9e01ea1c59da700aa9467dda17e331a903ff6ad766776ab0`). It was checked against agentenv-framework
+0.9.1431.
+
+- `envs/osmo/` is a computer app on the `ubuntu-24.04` base with the `reference` driver, for
+  `amd64` and `arm64`. It installs `osmo` from the distribution archive, launches `sh -c cd "$HOME" 2>/dev/null; exec 'osmo'` at boot and is ready
+  when a window of class `Osmo` appears.
+- Owned paths: `~/.config/osmo`, `~/.local/share/osmo`.
+  `data/get` returns their files and a typed JSON view of each; `data/reset` restores the seed.
+- Seed: 7 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/osmo/seed/` before publishing the bundle.
+
+## Task `add-contact`
+
+`tasks/add-contact.json` deploys the app, has the agent work through the computer from the prompt below, and grades
+the outcome with `artifacts/add-contact-check/verify.py`, which reads the app's `data/get` views and needs
+no model. `evals/osmo.toml` names it, so a run of the bundle runs it.
+
+> In Osmo, add a new contact to my address book: Delphine Moreau, cell phone 555-0163, e-mail delphine.moreau@example.com.
+
+Checks, each of which must pass:
+
+- `name`: `{"kind":"text_contains","file":".local/share/osmo/contacts_records.xml","pointer":"/root/children/[name=contacts_records]","value":"DelphineMoreau"}`
+- `phone`: `{"kind":"text_contains","file":".local/share/osmo/contacts_records.xml","pointer":"/root/children/[name=contacts_records]","value":"555-0163"}`
+- `email`: `{"kind":"text_contains","file":".local/share/osmo/contacts_records.xml","pointer":"/root/children/[name=contacts_records]","value":"delphine.moreau@example.com"}`
+- `kept`: `{"kind":"text_contains","file":".local/share/osmo/contacts_records.xml","pointer":"/root/children/[name=contacts_records]","value":"hannah.okafor@example.com"}`
+
+REA kept the task because its checks fail on the seed (`name`, `phone`, `email`) 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 add-contact --agent claude-code --model MODEL

bundle/artifacts/add-contact-check/verify.py

@@ -0,0 +1,443 @@
+"""Checks of the task add-contact against the osmo 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 = "osmo"
+CHECKS = [
+    {"id": "name", "kind": "text_contains", "file": ".local/share/osmo/contacts_records.xml", "pointer": "/root/children/[name=contacts_records]", "value": "DelphineMoreau"},
+    {"id": "phone", "kind": "text_contains", "file": ".local/share/osmo/contacts_records.xml", "pointer": "/root/children/[name=contacts_records]", "value": "555-0163"},
+    {"id": "email", "kind": "text_contains", "file": ".local/share/osmo/contacts_records.xml", "pointer": "/root/children/[name=contacts_records]", "value": "delphine.moreau@example.com"},
+    {"id": "kept", "kind": "text_contains", "file": ".local/share/osmo/contacts_records.xml", "pointer": "/root/children/[name=contacts_records]", "value": "hannah.okafor@example.com"},
+]
+
+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/osmo/SKILL.md

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

bundle/envs/osmo/env.toml

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

bundle/envs/osmo/osmo_app.py

@@ -0,0 +1,790 @@
+"""Osmo as an agentenv computer app, exported by REA from a desktop application capture.
+
+Package: osmo (captured at 0.4.4-2.1build2). Capture Evidence: ev_b5f9fb22877191be9e01ea1c59da700aa9467dda17e331a903ff6ad766776ab0.
+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 = [".config/osmo", ".local/share/osmo"]
+DCONF = ""
+TEXT_SEEDS = frozenset([".config/osmo/config.xml", ".config/osmo/lockfile", ".local/share/osmo/contacts_records.xml"])
+WINDOW_CLASS = "Osmo"
+
+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=["osmo"]),
+    launch=Launch(at="boot", command=["sh", "-c", "cd \"$HOME\" 2>/dev/null; exec 'osmo'"], window={"class": "Osmo"}, ready=Ready(window=True)),
+    paths=PATHS,
+    skill="SKILL.md",
+)
+class Osmo(ComputerAppEnvironment):
+    """Osmo, 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/osmo/seed/.config/osmo/config.xml

@@ -0,0 +1,214 @@
+<?xml version="1.0" encoding="utf-8"?>
+<osmo_config>
+  <general>
+    <window_x>0</window_x>
+    <window_y>0</window_y>
+    <window_size_x>950</window_size_x>
+    <window_size_y>560</window_size_y>
+    <fullscreen>0</fullscreen>
+    <enable_tooltips>1</enable_tooltips>
+    <latest_tab>0</latest_tab>
+    <tabs_position>2</tabs_position>
+    <remember_latest_tab>1</remember_latest_tab>
+    <save_data_after_modification>1</save_data_after_modification>
+    <disable_underline_links>0</disable_underline_links>
+    <toolbar_exit_button>0</toolbar_exit_button>
+    <date_format>2</date_format>
+    <time_format>0</time_format>
+    <enable_systray>1</enable_systray>
+    <start_minimised_in_systray>0</start_minimised_in_systray>
+    <ignore_day_note_events>0</ignore_day_note_events>
+    <run_counter>0</run_counter>
+    <lastrun_date>739925</lastrun_date>
+    <lastrun_time>85685</lastrun_time>
+    <hide_calendar>0</hide_calendar>
+    <hide_tasks>0</hide_tasks>
+    <hide_contacts>0</hide_contacts>
+    <hide_notes>0</hide_notes>
+    <override_locale_settings>0</override_locale_settings>
+    <gui_layout>1</gui_layout>
+    <sound_alarm_repeat>1</sound_alarm_repeat>
+    <spell_lang>en_US.UTF-8</spell_lang>
+    <web_browser>firefox %s</web_browser>
+    <email_client>xdg-email %s</email_client>
+    <sound_player>aplay %s</sound_player>
+  </general>
+  <calendar>
+    <fy_window_size_x>750</fy_window_size_x>
+    <fy_window_size_y>550</fy_window_size_y>
+    <fy_simple_view>1</fy_simple_view>
+    <fy_alternative_view>0</fy_alternative_view>
+    <cb_window_size_x>570</cb_window_size_x>
+    <cb_window_size_y>680</cb_window_size_y>
+    <ib_window_size_x>550</ib_window_size_x>
+    <ib_window_size_y>650</ib_window_size_y>
+    <display_options>22</display_options>
+    <day_notes_visible>0</day_notes_visible>
+    <timeline_start>480</timeline_start>
+    <timeline_end>900</timeline_end>
+    <timeline_step>60</timeline_step>
+    <di_show_current_time>1</di_show_current_time>
+    <di_show_current_time_seconds>1</di_show_current_time_seconds>
+    <di_show_day_number>1</di_show_day_number>
+    <di_show_current_day_distance>1</di_show_current_day_distance>
+    <di_show_marked_days>1</di_show_marked_days>
+    <di_show_week_number>1</di_show_week_number>
+    <di_show_weekend_days>1</di_show_weekend_days>
+    <di_show_day_category>1</di_show_day_category>
+    <di_show_moon_phase>1</di_show_moon_phase>
+    <di_show_notes>1</di_show_notes>
+    <di_show_zodiac_sign>0</di_show_zodiac_sign>
+    <cursor_type>1</cursor_type>
+    <frame_cursor_thickness>2</frame_cursor_thickness>
+    <enable_auxilary_calendars>1</enable_auxilary_calendars>
+    <enable_day_mark>1</enable_day_mark>
+    <strikethrough_past_notes>0</strikethrough_past_notes>
+    <ascending_sorting_in_day_notes_browser>0</ascending_sorting_in_day_notes_browser>
+    <auxilary_calendars_state>0</auxilary_calendars_state>
+    <day_note_spell_checker>0</day_note_spell_checker>
+    <day_note_marker>'</day_note_marker>
+    <date_header_format>%e %B %Y</date_header_format>
+    <event_marker_type>0</event_marker_type>
+    <today_marker_type>1</today_marker_type>
+    <day_notes_browser_filter>0</day_notes_browser_filter>
+    <ical_export_pane_pos>180</ical_export_pane_pos>
+    <background_color>#FFFFFF</background_color>
+    <header_bg_color>#404048</header_bg_color>
+    <header_fg_color>#DDDDDD</header_fg_color>
+    <day_color>#555555</day_color>
+    <pf_day_color>#CCCCCC</pf_day_color>
+    <weekend_color>#880000</weekend_color>
+    <selection_color>#86ABD9</selection_color>
+    <mark_color>#CBE140</mark_color>
+    <mark_current_day_color>#E37751</mark_current_day_color>
+    <mark_current_day_alpha>32768</mark_current_day_alpha>
+    <birthday_mark_color>#EDD400</birthday_mark_color>
+    <selector_alpha>32768</selector_alpha>
+    <day_name_font>Sans Bold 20</day_name_font>
+    <calendar_font>Sans 18</calendar_font>
+    <notes_font>Sans 11</notes_font>
+    <cal_print_month_name_font>Sans Bold 40</cal_print_month_name_font>
+    <cal_print_day_name_font>Sans Bold 10</cal_print_day_name_font>
+    <cal_print_day_num_font>Sans Bold 16</cal_print_day_num_font>
+    <cal_print_event_font>Sans 7</cal_print_event_font>
+    <cal_print_event_length>256</cal_print_event_length>
+    <cal_print_padding>4</cal_print_padding>
+    <cal_print_page_orientation>0</cal_print_page_orientation>
+    <cal_print_tasks>1</cal_print_tasks>
+    <cal_print_birthdays>1</cal_print_birthdays>
+    <cal_print_namedays>1</cal_print_namedays>
+    <cal_print_day_notes>1</cal_print_day_notes>
+    <cal_print_ical>1</cal_print_ical>
+    <cal_print_disable_background>0</cal_print_disable_background>
+  </calendar>
+  <tasks>
+    <high_priority_in_bold>1</high_priority_in_bold>
+    <hide_completed>0</hide_completed>
+    <delete_completed>0</delete_completed>
+    <add_edit>0</add_edit>
+    <remember_category>0</remember_category>
+    <current_category>0</current_category>
+    <pane_pos>275</pane_pos>
+    <tasks_sorting_order>0</tasks_sorting_order>
+    <tasks_sorting_column>2</tasks_sorting_column>
+    <visible_due_date_column>1</visible_due_date_column>
+    <visible_type_column>1</visible_type_column>
+    <visible_priority_column>0</visible_priority_column>
+    <visible_category_column>0</visible_category_column>
+    <tasks_addedit_win_x>290</tasks_addedit_win_x>
+    <tasks_addedit_win_y>20</tasks_addedit_win_y>
+    <tasks_addedit_win_w>370</tasks_addedit_win_w>
+    <tasks_addedit_win_h>440</tasks_addedit_win_h>
+    <postpone_time>10</postpone_time>
+    <column_idx_0>0</column_idx_0>
+    <column_idx_0_width>50</column_idx_0_width>
+    <column_idx_1>1</column_idx_1>
+    <column_idx_1_width>50</column_idx_1_width>
+    <column_idx_2>2</column_idx_2>
+    <column_idx_2_width>100</column_idx_2_width>
+    <column_idx_3>3</column_idx_3>
+    <column_idx_3_width>100</column_idx_3_width>
+    <column_idx_4>4</column_idx_4>
+    <column_idx_4_width>100</column_idx_4_width>
+    <column_idx_5>5</column_idx_5>
+    <column_idx_5_width>100</column_idx_5_width>
+    <due_today_color>#00981E</due_today_color>
+    <due_7days_color>#0047B7</due_7days_color>
+    <past_due_color>#CB362C</past_due_color>
+    <task_info_font>Sans 14</task_info_font>
+    <global_notification_command></global_notification_command>
+  </tasks>
+  <contacts>
+    <find_mode>0</find_mode>
+    <hide_group_column>0</hide_group_column>
+    <maps_provider>0</maps_provider>
+    <pane_pos>275</pane_pos>
+    <photo_width>80</photo_width>
+    <visible_age_column>1</visible_age_column>
+    <visible_birthday_date_column>1</visible_birthday_date_column>
+    <visible_zodiac_sign_column>1</visible_zodiac_sign_column>
+    <contact_tag_color>#228B22</contact_tag_color>
+    <contact_link_color>blue</contact_link_color>
+    <contact_name_font_size>18</contact_name_font_size>
+    <contact_item_font_size>11</contact_item_font_size>
+    <export_format>0</export_format>
+    <export_fields>+++-+------------------------------------------------</export_fields>
+    <contacts_sorting_order>0</contacts_sorting_order>
+    <contacts_sorting_column>0</contacts_sorting_column>
+    <contacts_addedit_win_x>225</contacts_addedit_win_x>
+    <contacts_addedit_win_y>20</contacts_addedit_win_y>
+    <contacts_addedit_win_w>500</contacts_addedit_win_w>
+    <contacts_addedit_win_h>600</contacts_addedit_win_h>
+    <contacts_export_win_x>225</contacts_export_win_x>
+    <contacts_export_win_y>20</contacts_export_win_y>
+    <contacts_export_win_w>500</contacts_export_win_w>
+    <contacts_export_win_h>400</contacts_export_win_h>
+    <contacts_import_sel_win_x>60</contacts_import_sel_win_x>
+    <contacts_import_sel_win_y>20</contacts_import_sel_win_y>
+    <contacts_import_win_x>150</contacts_import_win_x>
+    <contacts_import_win_y>20</contacts_import_win_y>
+    <contacts_import_win_w>650</contacts_import_win_w>
+    <contacts_import_win_h>450</contacts_import_win_h>
+    <contacts_birthdays_win_w>650</contacts_birthdays_win_w>
+    <contacts_birthdays_win_h>700</contacts_birthdays_win_h>
+    <column_idx_0>0</column_idx_0>
+    <column_idx_0_width>150</column_idx_0_width>
+    <column_idx_1>1</column_idx_1>
+    <column_idx_1_width>150</column_idx_1_width>
+    <column_idx_2>2</column_idx_2>
+    <column_idx_2_width>150</column_idx_2_width>
+    <import_type>0</import_type>
+    <import_interface_type>0</import_interface_type>
+    <import_bluetooth_channel>1</import_bluetooth_channel>
+    <import_usb_interface>0</import_usb_interface>
+    <import_binary_xml>0</import_binary_xml>
+    <import_bluetooth_address>00:00:00:00:00:00</import_bluetooth_address>
+  </contacts>
+  <notes>
+    <enc_algorithm>1</enc_algorithm>
+    <enc_hashing>1</enc_hashing>
+    <comp_algorithm>0</comp_algorithm>
+    <comp_ratio>3</comp_ratio>
+    <sorting_order>0</sorting_order>
+    <sorting_column>1</sorting_column>
+    <visible_type_column>1</visible_type_column>
+    <visible_category_column>1</visible_category_column>
+    <visible_last_changes_column>1</visible_last_changes_column>
+    <visible_created_column>1</visible_created_column>
+    <column_idx_0>0</column_idx_0>
+    <column_idx_0_width>50</column_idx_0_width>
+    <column_idx_1>1</column_idx_1>
+    <column_idx_1_width>200</column_idx_1_width>
+    <column_idx_2>2</column_idx_2>
+    <column_idx_2_width>80</column_idx_2_width>
+    <column_idx_3>3</column_idx_3>
+    <column_idx_3_width>150</column_idx_3_width>
+    <column_idx_4>4</column_idx_4>
+    <column_idx_4_width>150</column_idx_4_width>
+    <remember_category>0</remember_category>
+    <current_category>0</current_category>
+    <use_system_date>0</use_system_date>
+    <text_separator>=</text_separator>
+    <editor_font>Sans 11</editor_font>
+  </notes>
+</osmo_config>

bundle/envs/osmo/seed/.local/share/osmo/contacts_records.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<osmo_contacts>
+  <contacts_groups/>
+  <contacts_records>
+    <record>
+      <group>None</group>
+      <first_name>Hannah</first_name>
+      <last_name>Okafor</last_name>
+      <birthday_date>0</birthday_date>
+      <name_day_date>0</name_day_date>
+      <home_city>Riverton</home_city>
+      <organization>Bluefield Bakery</organization>
+      <cell_phone_1>555-0142</cell_phone_1>
+      <email_1>hannah.okafor@example.com</email_1>
+    </record>
+    <record>
+      <group>None</group>
+      <first_name>Tomasz</first_name>
+      <last_name>Brennan</last_name>
+      <birthday_date>0</birthday_date>
+      <name_day_date>0</name_day_date>
+      <home_city>Lakeport</home_city>
+      <organization>Northgate Cycles</organization>
+      <cell_phone_1>555-0187</cell_phone_1>
+      <email_1>tomasz.brennan@example.net</email_1>
+    </record>
+    <record>
+      <group>None</group>
+      <first_name>Ingrid</first_name>
+      <last_name>Achterberg</last_name>
+      <birthday_date>0</birthday_date>
+      <name_day_date>0</name_day_date>
+      <home_city>Millbrook</home_city>
+      <organization>Copperleaf Studio</organization>
+      <cell_phone_1>555-0119</cell_phone_1>
+      <email_1>ingrid.achterberg@example.org</email_1>
+    </record>
+  </contacts_records>
+</osmo_contacts>

bundle/envs/osmo/seed/.local/share/osmo/mediakeys/v1/salt

@@ -0,0 +1 @@
+C���ҹAe

bundle/envs/osmo/seed/.local/share/osmo/storage/salt

@@ -0,0 +1 @@
+��I�~�l7

bundle/evals/osmo.toml

@@ -0,0 +1 @@
+tasks = ["add-contact"]

bundle/tasks/add-contact.json

@@ -0,0 +1,9 @@
+[
+  {"id":"env","type":"deploy_env","env_id":"osmo"},
+  {"id":"agent","type":"deploy_agent","env_ids":["osmo"]},
+  {"id":"skills","type":"add_skills","env_ids":["osmo"]},
+  {"id":"record","type":"start_computer_recording","env_id":"osmo","name":"agent","depends_on":["env"]},
+  {"id":"task","type":"prompt_agent","depends_on":["skills","record"],"prompt":"In Osmo, add a new contact to my address book: Delphine Moreau, cell phone 555-0163, e-mail delphine.moreau@example.com."},
+  {"id":"check","type":"env_outcome_verifier","env_id":"osmo","file_artifact_id":"add-contact-check","verifier_id":"add-contact","depends_on":["task"]},
+  {"id":"end","type":"end_computer_recording","name":"agent","depends_on":["task"]}
+]

bundle/tasks/smoke.json

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

media/solve-1.mp4

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

media/solve-2.mp4

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

media/solve-3.mp4

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

media/witness.mp4

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

results.json

@@ -0,0 +1,111 @@
+{
+  "environment": "Osmo",
+  "app_version": "Osmo 0.4 personal organizer",
+  "task": "add-contact",
+  "prompt": "In Osmo, add a new contact to my address book: Delphine Moreau, cell phone 555-0163, e-mail delphine.moreau@example.com.",
+  "agent": "claude-code",
+  "model": "claude-sonnet-5-5",
+  "agentenv_framework": "0.9.1431",
+  "witness": "checks failed on the seed, passed after a contact was added through computer actions, failed on a near miss (the phone edited to 555-0136) and failed again after data/reset, in a fresh computer; held on the first try",
+  "runs": [
+    {
+      "run": 1,
+      "verdict": "passed",
+      "turns": 17,
+      "usd": 1.19,
+      "checks": {
+        "add-contact": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "name",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"DelphineMoreau\""
+            },
+            {
+              "id": "phone",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"555-0163\""
+            },
+            {
+              "id": "email",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"delphine.moreau@example.com\""
+            },
+            {
+              "id": "kept",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"hannah.okafor@example.com\""
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 2,
+      "verdict": "passed",
+      "turns": 17,
+      "usd": 0.96,
+      "checks": {
+        "add-contact": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "name",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"DelphineMoreau\""
+            },
+            {
+              "id": "phone",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"555-0163\""
+            },
+            {
+              "id": "email",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"delphine.moreau@example.com\""
+            },
+            {
+              "id": "kept",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"hannah.okafor@example.com\""
+            }
+          ]
+        }
+      }
+    },
+    {
+      "run": 3,
+      "verdict": "passed",
+      "turns": 20,
+      "usd": 0.81,
+      "checks": {
+        "add-contact": {
+          "score": 1.0,
+          "results": [
+            {
+              "id": "name",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"DelphineMoreau\""
+            },
+            {
+              "id": "phone",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"555-0163\""
+            },
+            {
+              "id": "email",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"delphine.moreau@example.com\""
+            },
+            {
+              "id": "kept",
+              "result": true,
+              "description": ".local/share/osmo/contacts_records.xml at /root/children/[name=contacts_records] has text containing \"hannah.okafor@example.com\""
+            }
+          ]
+        }
+      }
+    }
+  ]
+}